@bun-win32/propsys 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/AI.md +71 -0
- package/README.md +73 -0
- package/index.ts +4 -0
- package/package.json +57 -0
- package/structs/Propsys.ts +1432 -0
- package/types/Propsys.ts +151 -0
|
@@ -0,0 +1,1432 @@
|
|
|
1
|
+
import { type FFIFunction, FFIType } from 'bun:ffi';
|
|
2
|
+
|
|
3
|
+
import { Win32 } from '@bun-win32/core';
|
|
4
|
+
|
|
5
|
+
import type {
|
|
6
|
+
BOOL,
|
|
7
|
+
BSTR,
|
|
8
|
+
DOUBLE,
|
|
9
|
+
DWORD,
|
|
10
|
+
GETPROPERTYSTOREFLAGS,
|
|
11
|
+
HINSTANCE,
|
|
12
|
+
HRESULT,
|
|
13
|
+
HWND,
|
|
14
|
+
IDelayedPropertyStoreFactory,
|
|
15
|
+
INT,
|
|
16
|
+
IPropertyBag,
|
|
17
|
+
IPropertyDescription,
|
|
18
|
+
IPropertySetStorage,
|
|
19
|
+
IPropertyStore,
|
|
20
|
+
IStream,
|
|
21
|
+
IUnknown,
|
|
22
|
+
LONG,
|
|
23
|
+
LONGLONG,
|
|
24
|
+
LPBOOL,
|
|
25
|
+
LPBSTR,
|
|
26
|
+
LPCLSID,
|
|
27
|
+
LPCWSTR,
|
|
28
|
+
LPDOUBLE,
|
|
29
|
+
LPDWORD,
|
|
30
|
+
LPFILETIME,
|
|
31
|
+
LPGUID,
|
|
32
|
+
LPINT,
|
|
33
|
+
LPLONG,
|
|
34
|
+
LPLONGLONG,
|
|
35
|
+
LPLPBOOL,
|
|
36
|
+
LPLPDOUBLE,
|
|
37
|
+
LPLPFILETIME,
|
|
38
|
+
LPLPLONG,
|
|
39
|
+
LPLPLONGLONG,
|
|
40
|
+
LPLPPWSTR,
|
|
41
|
+
LPLPSERIALIZEDPROPERTYVALUE,
|
|
42
|
+
LPLPSHORT,
|
|
43
|
+
LPLPULONG,
|
|
44
|
+
LPLPULONGLONG,
|
|
45
|
+
LPLPUSHORT,
|
|
46
|
+
LPLPVOID,
|
|
47
|
+
LPLPWSTR,
|
|
48
|
+
LPPCWSTR,
|
|
49
|
+
LPPKA_FLAGS,
|
|
50
|
+
LPPOINTL,
|
|
51
|
+
LPPOINTS,
|
|
52
|
+
LPPROPERTYKEY,
|
|
53
|
+
LPPROPVARIANT,
|
|
54
|
+
LPPWSTR,
|
|
55
|
+
LPRECTL,
|
|
56
|
+
LPSERIALIZEDPROPERTYVALUE,
|
|
57
|
+
LPSHORT,
|
|
58
|
+
LPSTREAM,
|
|
59
|
+
LPSTRRET,
|
|
60
|
+
LPULONG,
|
|
61
|
+
LPULONGLONG,
|
|
62
|
+
LPUNKNOWN,
|
|
63
|
+
LPUSHORT,
|
|
64
|
+
LPVARIANT,
|
|
65
|
+
LPVOID,
|
|
66
|
+
LPWORD,
|
|
67
|
+
LPWSTR,
|
|
68
|
+
NULL,
|
|
69
|
+
PCUITEMID_CHILD,
|
|
70
|
+
PCUSERIALIZEDPROPSTORAGE,
|
|
71
|
+
PCWSTR,
|
|
72
|
+
PKA_FLAGS,
|
|
73
|
+
PROPDESC_ENUMFILTER,
|
|
74
|
+
PROPDESC_FORMAT_FLAGS,
|
|
75
|
+
PROPVAR_CHANGE_FLAGS,
|
|
76
|
+
PROPVAR_COMPARE_FLAGS,
|
|
77
|
+
PROPVAR_COMPARE_UNIT,
|
|
78
|
+
PSTIME_FLAGS,
|
|
79
|
+
PWSTR,
|
|
80
|
+
REFCLSID,
|
|
81
|
+
REFGUID,
|
|
82
|
+
REFIID,
|
|
83
|
+
REFPROPERTYKEY,
|
|
84
|
+
REFPROPVARIANT,
|
|
85
|
+
REFVARIANT,
|
|
86
|
+
SHORT,
|
|
87
|
+
UINT,
|
|
88
|
+
ULONG,
|
|
89
|
+
ULONGLONG,
|
|
90
|
+
USHORT,
|
|
91
|
+
VARTYPE,
|
|
92
|
+
} from '../types/Propsys';
|
|
93
|
+
|
|
94
|
+
/**
|
|
95
|
+
* Thin, lazy-loaded FFI bindings for `propsys.dll` (Windows Property System).
|
|
96
|
+
*
|
|
97
|
+
* Each static method maps one-to-one with a documented `propsys.dll` export declared
|
|
98
|
+
* in `Symbols`. The first call to a method binds the underlying native symbol via
|
|
99
|
+
* `bun:ffi` and memoizes it on the class; subsequent calls skip binding entirely.
|
|
100
|
+
* For bulk, up-front binding use `Preload`.
|
|
101
|
+
*
|
|
102
|
+
* @example
|
|
103
|
+
* ```ts
|
|
104
|
+
* import Propsys from '@bun-win32/propsys';
|
|
105
|
+
*
|
|
106
|
+
* const key = Buffer.alloc(20); // PROPERTYKEY
|
|
107
|
+
* Propsys.PSGetPropertyKeyFromName(Buffer.from('System.Title\0', 'utf16le').ptr!, key.ptr!);
|
|
108
|
+
* ```
|
|
109
|
+
*/
|
|
110
|
+
class Propsys extends Win32 {
|
|
111
|
+
protected static override name = 'propsys.dll';
|
|
112
|
+
|
|
113
|
+
/** @inheritdoc */
|
|
114
|
+
protected static override readonly Symbols = {
|
|
115
|
+
ClearPropVariantArray: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.void },
|
|
116
|
+
ClearVariantArray: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.void },
|
|
117
|
+
InitPropVariantFromBooleanVector: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
118
|
+
InitPropVariantFromBuffer: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
119
|
+
InitPropVariantFromCLSID: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
120
|
+
InitPropVariantFromDoubleVector: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
121
|
+
InitPropVariantFromFileTime: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
122
|
+
InitPropVariantFromFileTimeVector: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
123
|
+
InitPropVariantFromGUIDAsString: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
124
|
+
InitPropVariantFromInt16Vector: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
125
|
+
InitPropVariantFromInt32Vector: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
126
|
+
InitPropVariantFromInt64Vector: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
127
|
+
InitPropVariantFromPropVariantVectorElem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
128
|
+
InitPropVariantFromResource: { args: [FFIType.u64, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
129
|
+
InitPropVariantFromStrRet: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
130
|
+
InitPropVariantFromStringAsVector: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
131
|
+
InitPropVariantFromStringVector: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
132
|
+
InitPropVariantFromUInt16Vector: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
133
|
+
InitPropVariantFromUInt32Vector: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
134
|
+
InitPropVariantFromUInt64Vector: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
135
|
+
InitPropVariantVectorFromPropVariant: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
136
|
+
InitVariantFromBooleanArray: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
137
|
+
InitVariantFromBuffer: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
138
|
+
InitVariantFromDoubleArray: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
139
|
+
InitVariantFromFileTime: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
140
|
+
InitVariantFromFileTimeArray: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
141
|
+
InitVariantFromGUIDAsString: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
142
|
+
InitVariantFromInt16Array: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
143
|
+
InitVariantFromInt32Array: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
144
|
+
InitVariantFromInt64Array: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
145
|
+
InitVariantFromResource: { args: [FFIType.u64, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
146
|
+
InitVariantFromStrRet: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
147
|
+
InitVariantFromStringArray: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
148
|
+
InitVariantFromUInt16Array: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
149
|
+
InitVariantFromUInt32Array: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
150
|
+
InitVariantFromUInt64Array: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
151
|
+
InitVariantFromVariantArrayElem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
152
|
+
PSCoerceToCanonicalValue: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
153
|
+
PSCreateAdapterFromPropertyStore: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
154
|
+
PSCreateDelayedMultiplexPropertyStore: { args: [FFIType.i32, FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
155
|
+
PSCreateMemoryPropertyStore: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
156
|
+
PSCreateMultiplexPropertyStore: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
157
|
+
PSCreatePropertyChangeArray: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
158
|
+
PSCreatePropertyStoreFromObject: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
159
|
+
PSCreatePropertyStoreFromPropertySetStorage: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
160
|
+
PSCreateSimplePropertyChange: { args: [FFIType.i32, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
161
|
+
PSEnumeratePropertyDescriptions: { args: [FFIType.i32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
162
|
+
PSFormatForDisplay: { args: [FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
|
|
163
|
+
PSFormatForDisplayAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
|
|
164
|
+
PSFormatPropertyValue: { args: [FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
|
|
165
|
+
PSGetImageReferenceForValue: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
166
|
+
PSGetItemPropertyHandler: { args: [FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
167
|
+
PSGetItemPropertyHandlerWithCreateObject: { args: [FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
168
|
+
PSGetNameFromPropertyKey: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
169
|
+
PSGetNamedPropertyFromPropertyStorage: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
170
|
+
PSGetPropertyDescription: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
171
|
+
PSGetPropertyDescriptionByName: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
172
|
+
PSGetPropertyDescriptionListFromString: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
173
|
+
PSGetPropertyFromPropertyStorage: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
174
|
+
PSGetPropertyKeyFromName: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
175
|
+
PSGetPropertySystem: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
176
|
+
PSGetPropertyValue: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
177
|
+
PSLookupPropertyHandlerCLSID: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
178
|
+
PSPropertyBag_Delete: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
179
|
+
PSPropertyBag_ReadBOOL: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
180
|
+
PSPropertyBag_ReadBSTR: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
181
|
+
PSPropertyBag_ReadDWORD: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
182
|
+
PSPropertyBag_ReadGUID: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
183
|
+
PSPropertyBag_ReadInt: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
184
|
+
PSPropertyBag_ReadLONG: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
185
|
+
PSPropertyBag_ReadPOINTL: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
186
|
+
PSPropertyBag_ReadPOINTS: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
187
|
+
PSPropertyBag_ReadPropertyKey: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
188
|
+
PSPropertyBag_ReadRECTL: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
189
|
+
PSPropertyBag_ReadSHORT: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
190
|
+
PSPropertyBag_ReadStr: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
|
|
191
|
+
PSPropertyBag_ReadStrAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
192
|
+
PSPropertyBag_ReadStream: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
193
|
+
PSPropertyBag_ReadType: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u16], returns: FFIType.i32 },
|
|
194
|
+
PSPropertyBag_ReadULONGLONG: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
195
|
+
PSPropertyBag_ReadUnknown: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
196
|
+
PSPropertyBag_WriteBOOL: { args: [FFIType.ptr, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
|
|
197
|
+
PSPropertyBag_WriteBSTR: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
198
|
+
PSPropertyBag_WriteDWORD: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
|
|
199
|
+
PSPropertyBag_WriteGUID: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
200
|
+
PSPropertyBag_WriteInt: { args: [FFIType.ptr, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
|
|
201
|
+
PSPropertyBag_WriteLONG: { args: [FFIType.ptr, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
|
|
202
|
+
PSPropertyBag_WritePOINTL: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
203
|
+
PSPropertyBag_WritePOINTS: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
204
|
+
PSPropertyBag_WritePropertyKey: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
205
|
+
PSPropertyBag_WriteRECTL: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
206
|
+
PSPropertyBag_WriteSHORT: { args: [FFIType.ptr, FFIType.ptr, FFIType.i16], returns: FFIType.i32 },
|
|
207
|
+
PSPropertyBag_WriteStr: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
208
|
+
PSPropertyBag_WriteStream: { args: [FFIType.ptr, FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
|
|
209
|
+
PSPropertyBag_WriteULONGLONG: { args: [FFIType.ptr, FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
|
|
210
|
+
PSPropertyBag_WriteUnknown: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
211
|
+
PSPropertyKeyFromString: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
212
|
+
PSRefreshPropertySchema: { args: [], returns: FFIType.i32 },
|
|
213
|
+
PSRegisterPropertySchema: { args: [FFIType.ptr], returns: FFIType.i32 },
|
|
214
|
+
PSSetPropertyValue: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
215
|
+
PSStringFromPropertyKey: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
|
|
216
|
+
PSUnregisterPropertySchema: { args: [FFIType.ptr], returns: FFIType.i32 },
|
|
217
|
+
PropVariantChangeType: { args: [FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.u16], returns: FFIType.i32 },
|
|
218
|
+
PropVariantCompareEx: { args: [FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.i32], returns: FFIType.i32 },
|
|
219
|
+
PropVariantGetBooleanElem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
220
|
+
PropVariantGetDoubleElem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
221
|
+
PropVariantGetElementCount: { args: [FFIType.ptr], returns: FFIType.u32 },
|
|
222
|
+
PropVariantGetFileTimeElem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
223
|
+
PropVariantGetInt16Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
224
|
+
PropVariantGetInt32Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
225
|
+
PropVariantGetInt64Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
226
|
+
PropVariantGetStringElem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
227
|
+
PropVariantGetUInt16Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
228
|
+
PropVariantGetUInt32Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
229
|
+
PropVariantGetUInt64Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
230
|
+
PropVariantToBSTR: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
231
|
+
PropVariantToBoolean: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
232
|
+
PropVariantToBooleanVector: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
233
|
+
PropVariantToBooleanVectorAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
234
|
+
PropVariantToBooleanWithDefault: { args: [FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
|
|
235
|
+
PropVariantToBuffer: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
|
|
236
|
+
PropVariantToDouble: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
237
|
+
PropVariantToDoubleVector: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
238
|
+
PropVariantToDoubleVectorAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
239
|
+
PropVariantToDoubleWithDefault: { args: [FFIType.ptr, FFIType.f64], returns: FFIType.f64 },
|
|
240
|
+
PropVariantToFileTime: { args: [FFIType.ptr, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
|
|
241
|
+
PropVariantToFileTimeVector: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
242
|
+
PropVariantToFileTimeVectorAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
243
|
+
PropVariantToGUID: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
244
|
+
PropVariantToInt16: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
245
|
+
PropVariantToInt16Vector: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
246
|
+
PropVariantToInt16VectorAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
247
|
+
PropVariantToInt16WithDefault: { args: [FFIType.ptr, FFIType.i16], returns: FFIType.i16 },
|
|
248
|
+
PropVariantToInt32: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
249
|
+
PropVariantToInt32Vector: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
250
|
+
PropVariantToInt32VectorAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
251
|
+
PropVariantToInt32WithDefault: { args: [FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
|
|
252
|
+
PropVariantToInt64: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
253
|
+
PropVariantToInt64Vector: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
254
|
+
PropVariantToInt64VectorAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
255
|
+
PropVariantToInt64WithDefault: { args: [FFIType.ptr, FFIType.i64], returns: FFIType.i64 },
|
|
256
|
+
PropVariantToStrRet: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
257
|
+
PropVariantToString: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
|
|
258
|
+
PropVariantToStringAlloc: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
259
|
+
PropVariantToStringVector: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
260
|
+
PropVariantToStringVectorAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
261
|
+
PropVariantToStringWithDefault: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
|
|
262
|
+
PropVariantToUInt16: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
263
|
+
PropVariantToUInt16Vector: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
264
|
+
PropVariantToUInt16VectorAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
265
|
+
PropVariantToUInt16WithDefault: { args: [FFIType.ptr, FFIType.u16], returns: FFIType.u16 },
|
|
266
|
+
PropVariantToUInt32: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
267
|
+
PropVariantToUInt32Vector: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
268
|
+
PropVariantToUInt32VectorAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
269
|
+
PropVariantToUInt32WithDefault: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
|
|
270
|
+
PropVariantToUInt64: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
271
|
+
PropVariantToUInt64Vector: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
272
|
+
PropVariantToUInt64VectorAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
273
|
+
PropVariantToUInt64WithDefault: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.u64 },
|
|
274
|
+
PropVariantToVariant: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
275
|
+
PropVariantToWinRTPropertyValue: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
276
|
+
SHGetPropertyStoreForWindow: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
277
|
+
StgDeserializePropVariant: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
278
|
+
StgSerializePropVariant: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
279
|
+
VariantCompare: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
280
|
+
VariantGetBooleanElem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
281
|
+
VariantGetDoubleElem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
282
|
+
VariantGetElementCount: { args: [FFIType.ptr], returns: FFIType.u32 },
|
|
283
|
+
VariantGetInt16Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
284
|
+
VariantGetInt32Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
285
|
+
VariantGetInt64Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
286
|
+
VariantGetStringElem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
287
|
+
VariantGetUInt16Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
288
|
+
VariantGetUInt32Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
289
|
+
VariantGetUInt64Elem: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
290
|
+
VariantToBoolean: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
291
|
+
VariantToBooleanArray: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
292
|
+
VariantToBooleanArrayAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
293
|
+
VariantToBooleanWithDefault: { args: [FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
|
|
294
|
+
VariantToBuffer: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
|
|
295
|
+
VariantToDosDateTime: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
296
|
+
VariantToDouble: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
297
|
+
VariantToDoubleArray: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
298
|
+
VariantToDoubleArrayAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
299
|
+
VariantToDoubleWithDefault: { args: [FFIType.ptr, FFIType.f64], returns: FFIType.f64 },
|
|
300
|
+
VariantToFileTime: { args: [FFIType.ptr, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
|
|
301
|
+
VariantToGUID: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
302
|
+
VariantToInt16: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
303
|
+
VariantToInt16Array: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
304
|
+
VariantToInt16ArrayAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
305
|
+
VariantToInt16WithDefault: { args: [FFIType.ptr, FFIType.i16], returns: FFIType.i16 },
|
|
306
|
+
VariantToInt32: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
307
|
+
VariantToInt32Array: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
308
|
+
VariantToInt32ArrayAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
309
|
+
VariantToInt32WithDefault: { args: [FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
|
|
310
|
+
VariantToInt64: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
311
|
+
VariantToInt64Array: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
312
|
+
VariantToInt64ArrayAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
313
|
+
VariantToInt64WithDefault: { args: [FFIType.ptr, FFIType.i64], returns: FFIType.i64 },
|
|
314
|
+
VariantToPropVariant: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
315
|
+
VariantToStrRet: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
316
|
+
VariantToString: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
|
|
317
|
+
VariantToStringAlloc: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
318
|
+
VariantToStringArray: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
319
|
+
VariantToStringArrayAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
320
|
+
VariantToStringWithDefault: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
|
|
321
|
+
VariantToUInt16: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
322
|
+
VariantToUInt16Array: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
323
|
+
VariantToUInt16ArrayAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
324
|
+
VariantToUInt16WithDefault: { args: [FFIType.ptr, FFIType.u16], returns: FFIType.u16 },
|
|
325
|
+
VariantToUInt32: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
326
|
+
VariantToUInt32Array: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
327
|
+
VariantToUInt32ArrayAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
328
|
+
VariantToUInt32WithDefault: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
|
|
329
|
+
VariantToUInt64: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
330
|
+
VariantToUInt64Array: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
|
|
331
|
+
VariantToUInt64ArrayAlloc: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
332
|
+
VariantToUInt64WithDefault: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.u64 },
|
|
333
|
+
WinRTPropertyValueToPropVariant: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
|
|
334
|
+
} as const satisfies Record<string, FFIFunction>;
|
|
335
|
+
|
|
336
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-clearpropvariantarray
|
|
337
|
+
public static ClearPropVariantArray(rgPropVar: LPPROPVARIANT, cVars: UINT): void {
|
|
338
|
+
return Propsys.Load('ClearPropVariantArray')(rgPropVar, cVars);
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-clearvariantarray
|
|
342
|
+
public static ClearVariantArray(pvars: LPVARIANT, cvars: UINT): void {
|
|
343
|
+
return Propsys.Load('ClearVariantArray')(pvars, cvars);
|
|
344
|
+
}
|
|
345
|
+
|
|
346
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfrombooleanvector
|
|
347
|
+
public static InitPropVariantFromBooleanVector(prgf: LPBOOL | NULL, cElems: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
348
|
+
return Propsys.Load('InitPropVariantFromBooleanVector')(prgf, cElems, ppropvar);
|
|
349
|
+
}
|
|
350
|
+
|
|
351
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfrombuffer
|
|
352
|
+
public static InitPropVariantFromBuffer(pv: LPVOID, cb: UINT, ppropvar: LPPROPVARIANT): HRESULT {
|
|
353
|
+
return Propsys.Load('InitPropVariantFromBuffer')(pv, cb, ppropvar);
|
|
354
|
+
}
|
|
355
|
+
|
|
356
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromclsid
|
|
357
|
+
public static InitPropVariantFromCLSID(clsid: REFCLSID, ppropvar: LPPROPVARIANT): HRESULT {
|
|
358
|
+
return Propsys.Load('InitPropVariantFromCLSID')(clsid, ppropvar);
|
|
359
|
+
}
|
|
360
|
+
|
|
361
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromdoublevector
|
|
362
|
+
public static InitPropVariantFromDoubleVector(prgn: LPDOUBLE | NULL, cElems: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
363
|
+
return Propsys.Load('InitPropVariantFromDoubleVector')(prgn, cElems, ppropvar);
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromfiletime
|
|
367
|
+
public static InitPropVariantFromFileTime(pftIn: LPFILETIME, ppropvar: LPPROPVARIANT): HRESULT {
|
|
368
|
+
return Propsys.Load('InitPropVariantFromFileTime')(pftIn, ppropvar);
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromfiletimevector
|
|
372
|
+
public static InitPropVariantFromFileTimeVector(prgft: LPFILETIME | NULL, cElems: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
373
|
+
return Propsys.Load('InitPropVariantFromFileTimeVector')(prgft, cElems, ppropvar);
|
|
374
|
+
}
|
|
375
|
+
|
|
376
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromguidasstring
|
|
377
|
+
public static InitPropVariantFromGUIDAsString(guid: REFGUID, ppropvar: LPPROPVARIANT): HRESULT {
|
|
378
|
+
return Propsys.Load('InitPropVariantFromGUIDAsString')(guid, ppropvar);
|
|
379
|
+
}
|
|
380
|
+
|
|
381
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromint16vector
|
|
382
|
+
public static InitPropVariantFromInt16Vector(prgn: LPSHORT | NULL, cElems: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
383
|
+
return Propsys.Load('InitPropVariantFromInt16Vector')(prgn, cElems, ppropvar);
|
|
384
|
+
}
|
|
385
|
+
|
|
386
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromint32vector
|
|
387
|
+
public static InitPropVariantFromInt32Vector(prgn: LPLONG | NULL, cElems: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
388
|
+
return Propsys.Load('InitPropVariantFromInt32Vector')(prgn, cElems, ppropvar);
|
|
389
|
+
}
|
|
390
|
+
|
|
391
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromint64vector
|
|
392
|
+
public static InitPropVariantFromInt64Vector(prgn: LPLONGLONG | NULL, cElems: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
393
|
+
return Propsys.Load('InitPropVariantFromInt64Vector')(prgn, cElems, ppropvar);
|
|
394
|
+
}
|
|
395
|
+
|
|
396
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfrompropvariantvectorelem
|
|
397
|
+
public static InitPropVariantFromPropVariantVectorElem(propvarIn: REFPROPVARIANT, iElem: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
398
|
+
return Propsys.Load('InitPropVariantFromPropVariantVectorElem')(propvarIn, iElem, ppropvar);
|
|
399
|
+
}
|
|
400
|
+
|
|
401
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromresource
|
|
402
|
+
public static InitPropVariantFromResource(hinst: HINSTANCE, id: UINT, ppropvar: LPPROPVARIANT): HRESULT {
|
|
403
|
+
return Propsys.Load('InitPropVariantFromResource')(hinst, id, ppropvar);
|
|
404
|
+
}
|
|
405
|
+
|
|
406
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromstrret
|
|
407
|
+
public static InitPropVariantFromStrRet(pstrret: LPSTRRET, pidl: PCUITEMID_CHILD | NULL, ppropvar: LPPROPVARIANT): HRESULT {
|
|
408
|
+
return Propsys.Load('InitPropVariantFromStrRet')(pstrret, pidl, ppropvar);
|
|
409
|
+
}
|
|
410
|
+
|
|
411
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromstringasvector
|
|
412
|
+
public static InitPropVariantFromStringAsVector(psz: PCWSTR | NULL, ppropvar: LPPROPVARIANT): HRESULT {
|
|
413
|
+
return Propsys.Load('InitPropVariantFromStringAsVector')(psz, ppropvar);
|
|
414
|
+
}
|
|
415
|
+
|
|
416
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromstringvector
|
|
417
|
+
public static InitPropVariantFromStringVector(prgsz: LPPCWSTR | NULL, cElems: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
418
|
+
return Propsys.Load('InitPropVariantFromStringVector')(prgsz, cElems, ppropvar);
|
|
419
|
+
}
|
|
420
|
+
|
|
421
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromuint16vector
|
|
422
|
+
public static InitPropVariantFromUInt16Vector(prgn: LPUSHORT | NULL, cElems: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
423
|
+
return Propsys.Load('InitPropVariantFromUInt16Vector')(prgn, cElems, ppropvar);
|
|
424
|
+
}
|
|
425
|
+
|
|
426
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromuint32vector
|
|
427
|
+
public static InitPropVariantFromUInt32Vector(prgn: LPULONG | NULL, cElems: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
428
|
+
return Propsys.Load('InitPropVariantFromUInt32Vector')(prgn, cElems, ppropvar);
|
|
429
|
+
}
|
|
430
|
+
|
|
431
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantfromuint64vector
|
|
432
|
+
public static InitPropVariantFromUInt64Vector(prgn: LPULONGLONG | NULL, cElems: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
433
|
+
return Propsys.Load('InitPropVariantFromUInt64Vector')(prgn, cElems, ppropvar);
|
|
434
|
+
}
|
|
435
|
+
|
|
436
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initpropvariantvectorfrompropvariant
|
|
437
|
+
public static InitPropVariantVectorFromPropVariant(propvarSingle: REFPROPVARIANT, ppropvarVector: LPPROPVARIANT): HRESULT {
|
|
438
|
+
return Propsys.Load('InitPropVariantVectorFromPropVariant')(propvarSingle, ppropvarVector);
|
|
439
|
+
}
|
|
440
|
+
|
|
441
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfrombooleanarray
|
|
442
|
+
public static InitVariantFromBooleanArray(prgf: LPBOOL, cElems: ULONG, pvar: LPVARIANT): HRESULT {
|
|
443
|
+
return Propsys.Load('InitVariantFromBooleanArray')(prgf, cElems, pvar);
|
|
444
|
+
}
|
|
445
|
+
|
|
446
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfrombuffer
|
|
447
|
+
public static InitVariantFromBuffer(pv: LPVOID, cb: UINT, pvar: LPVARIANT): HRESULT {
|
|
448
|
+
return Propsys.Load('InitVariantFromBuffer')(pv, cb, pvar);
|
|
449
|
+
}
|
|
450
|
+
|
|
451
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromdoublearray
|
|
452
|
+
public static InitVariantFromDoubleArray(prgn: LPDOUBLE, cElems: ULONG, pvar: LPVARIANT): HRESULT {
|
|
453
|
+
return Propsys.Load('InitVariantFromDoubleArray')(prgn, cElems, pvar);
|
|
454
|
+
}
|
|
455
|
+
|
|
456
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromfiletime
|
|
457
|
+
public static InitVariantFromFileTime(pft: LPFILETIME, pvar: LPVARIANT): HRESULT {
|
|
458
|
+
return Propsys.Load('InitVariantFromFileTime')(pft, pvar);
|
|
459
|
+
}
|
|
460
|
+
|
|
461
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromfiletimearray
|
|
462
|
+
public static InitVariantFromFileTimeArray(prgft: LPFILETIME | NULL, cElems: ULONG, pvar: LPVARIANT): HRESULT {
|
|
463
|
+
return Propsys.Load('InitVariantFromFileTimeArray')(prgft, cElems, pvar);
|
|
464
|
+
}
|
|
465
|
+
|
|
466
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromguidasstring
|
|
467
|
+
public static InitVariantFromGUIDAsString(guid: REFGUID, pvar: LPVARIANT): HRESULT {
|
|
468
|
+
return Propsys.Load('InitVariantFromGUIDAsString')(guid, pvar);
|
|
469
|
+
}
|
|
470
|
+
|
|
471
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromint16array
|
|
472
|
+
public static InitVariantFromInt16Array(prgn: LPSHORT, cElems: ULONG, pvar: LPVARIANT): HRESULT {
|
|
473
|
+
return Propsys.Load('InitVariantFromInt16Array')(prgn, cElems, pvar);
|
|
474
|
+
}
|
|
475
|
+
|
|
476
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromint32array
|
|
477
|
+
public static InitVariantFromInt32Array(prgn: LPLONG, cElems: ULONG, pvar: LPVARIANT): HRESULT {
|
|
478
|
+
return Propsys.Load('InitVariantFromInt32Array')(prgn, cElems, pvar);
|
|
479
|
+
}
|
|
480
|
+
|
|
481
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromint64array
|
|
482
|
+
public static InitVariantFromInt64Array(prgn: LPLONGLONG, cElems: ULONG, pvar: LPVARIANT): HRESULT {
|
|
483
|
+
return Propsys.Load('InitVariantFromInt64Array')(prgn, cElems, pvar);
|
|
484
|
+
}
|
|
485
|
+
|
|
486
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromresource
|
|
487
|
+
public static InitVariantFromResource(hinst: HINSTANCE, id: UINT, pvar: LPVARIANT): HRESULT {
|
|
488
|
+
return Propsys.Load('InitVariantFromResource')(hinst, id, pvar);
|
|
489
|
+
}
|
|
490
|
+
|
|
491
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromstrret
|
|
492
|
+
public static InitVariantFromStrRet(pstrret: LPSTRRET, pidl: PCUITEMID_CHILD, pvar: LPVARIANT): HRESULT {
|
|
493
|
+
return Propsys.Load('InitVariantFromStrRet')(pstrret, pidl, pvar);
|
|
494
|
+
}
|
|
495
|
+
|
|
496
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromstringarray
|
|
497
|
+
public static InitVariantFromStringArray(prgsz: LPPCWSTR, cElems: ULONG, pvar: LPVARIANT): HRESULT {
|
|
498
|
+
return Propsys.Load('InitVariantFromStringArray')(prgsz, cElems, pvar);
|
|
499
|
+
}
|
|
500
|
+
|
|
501
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromuint16array
|
|
502
|
+
public static InitVariantFromUInt16Array(prgn: LPUSHORT, cElems: ULONG, pvar: LPVARIANT): HRESULT {
|
|
503
|
+
return Propsys.Load('InitVariantFromUInt16Array')(prgn, cElems, pvar);
|
|
504
|
+
}
|
|
505
|
+
|
|
506
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromuint32array
|
|
507
|
+
public static InitVariantFromUInt32Array(prgn: LPULONG, cElems: ULONG, pvar: LPVARIANT): HRESULT {
|
|
508
|
+
return Propsys.Load('InitVariantFromUInt32Array')(prgn, cElems, pvar);
|
|
509
|
+
}
|
|
510
|
+
|
|
511
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromuint64array
|
|
512
|
+
public static InitVariantFromUInt64Array(prgn: LPULONGLONG, cElems: ULONG, pvar: LPVARIANT): HRESULT {
|
|
513
|
+
return Propsys.Load('InitVariantFromUInt64Array')(prgn, cElems, pvar);
|
|
514
|
+
}
|
|
515
|
+
|
|
516
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-initvariantfromvariantarrayelem
|
|
517
|
+
public static InitVariantFromVariantArrayElem(varIn: REFVARIANT, iElem: ULONG, pvar: LPVARIANT): HRESULT {
|
|
518
|
+
return Propsys.Load('InitVariantFromVariantArrayElem')(varIn, iElem, pvar);
|
|
519
|
+
}
|
|
520
|
+
|
|
521
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pscoercetocanonicalvalue
|
|
522
|
+
public static PSCoerceToCanonicalValue(key: REFPROPERTYKEY, ppropvar: LPPROPVARIANT): HRESULT {
|
|
523
|
+
return Propsys.Load('PSCoerceToCanonicalValue')(key, ppropvar);
|
|
524
|
+
}
|
|
525
|
+
|
|
526
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pscreateadapterfrompropertystore
|
|
527
|
+
public static PSCreateAdapterFromPropertyStore(pps: IPropertyStore, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
528
|
+
return Propsys.Load('PSCreateAdapterFromPropertyStore')(pps, riid, ppv);
|
|
529
|
+
}
|
|
530
|
+
|
|
531
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pscreatedelayedmultiplexpropertystore
|
|
532
|
+
public static PSCreateDelayedMultiplexPropertyStore(flags: GETPROPERTYSTOREFLAGS, pdpsf: IDelayedPropertyStoreFactory, rgStoreIds: LPDWORD, cStores: DWORD, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
533
|
+
return Propsys.Load('PSCreateDelayedMultiplexPropertyStore')(flags, pdpsf, rgStoreIds, cStores, riid, ppv);
|
|
534
|
+
}
|
|
535
|
+
|
|
536
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pscreatememorypropertystore
|
|
537
|
+
public static PSCreateMemoryPropertyStore(riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
538
|
+
return Propsys.Load('PSCreateMemoryPropertyStore')(riid, ppv);
|
|
539
|
+
}
|
|
540
|
+
|
|
541
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pscreatemultiplexpropertystore
|
|
542
|
+
public static PSCreateMultiplexPropertyStore(prgpunkStores: LPUNKNOWN, cStores: DWORD, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
543
|
+
return Propsys.Load('PSCreateMultiplexPropertyStore')(prgpunkStores, cStores, riid, ppv);
|
|
544
|
+
}
|
|
545
|
+
|
|
546
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pscreatepropertychangearray
|
|
547
|
+
public static PSCreatePropertyChangeArray(rgpropkey: LPPROPERTYKEY | NULL, rgflags: LPPKA_FLAGS | NULL, rgpropvar: LPPROPVARIANT | NULL, cChanges: UINT, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
548
|
+
return Propsys.Load('PSCreatePropertyChangeArray')(rgpropkey, rgflags, rgpropvar, cChanges, riid, ppv);
|
|
549
|
+
}
|
|
550
|
+
|
|
551
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pscreatepropertystorefromobject
|
|
552
|
+
public static PSCreatePropertyStoreFromObject(punk: IUnknown, grfMode: DWORD, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
553
|
+
return Propsys.Load('PSCreatePropertyStoreFromObject')(punk, grfMode, riid, ppv);
|
|
554
|
+
}
|
|
555
|
+
|
|
556
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pscreatepropertystorefrompropertysetstorage
|
|
557
|
+
public static PSCreatePropertyStoreFromPropertySetStorage(ppss: IPropertySetStorage, grfMode: DWORD, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
558
|
+
return Propsys.Load('PSCreatePropertyStoreFromPropertySetStorage')(ppss, grfMode, riid, ppv);
|
|
559
|
+
}
|
|
560
|
+
|
|
561
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pscreatesimplepropertychange
|
|
562
|
+
public static PSCreateSimplePropertyChange(flags: PKA_FLAGS, key: REFPROPERTYKEY, propvar: REFPROPVARIANT, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
563
|
+
return Propsys.Load('PSCreateSimplePropertyChange')(flags, key, propvar, riid, ppv);
|
|
564
|
+
}
|
|
565
|
+
|
|
566
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psenumeratepropertydescriptions
|
|
567
|
+
public static PSEnumeratePropertyDescriptions(filterOn: PROPDESC_ENUMFILTER, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
568
|
+
return Propsys.Load('PSEnumeratePropertyDescriptions')(filterOn, riid, ppv);
|
|
569
|
+
}
|
|
570
|
+
|
|
571
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psformatfordisplay
|
|
572
|
+
public static PSFormatForDisplay(propkey: REFPROPERTYKEY, propvar: REFPROPVARIANT, pdfFlags: PROPDESC_FORMAT_FLAGS, pwszText: LPWSTR, cchText: DWORD): HRESULT {
|
|
573
|
+
return Propsys.Load('PSFormatForDisplay')(propkey, propvar, pdfFlags, pwszText, cchText);
|
|
574
|
+
}
|
|
575
|
+
|
|
576
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psformatfordisplayalloc
|
|
577
|
+
public static PSFormatForDisplayAlloc(key: REFPROPERTYKEY, propvar: REFPROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, ppszDisplay: LPPWSTR): HRESULT {
|
|
578
|
+
return Propsys.Load('PSFormatForDisplayAlloc')(key, propvar, pdff, ppszDisplay);
|
|
579
|
+
}
|
|
580
|
+
|
|
581
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psformatpropertyvalue
|
|
582
|
+
public static PSFormatPropertyValue(pps: IPropertyStore, ppd: IPropertyDescription, pdff: PROPDESC_FORMAT_FLAGS, ppszDisplay: LPLPWSTR): HRESULT {
|
|
583
|
+
return Propsys.Load('PSFormatPropertyValue')(pps, ppd, pdff, ppszDisplay);
|
|
584
|
+
}
|
|
585
|
+
|
|
586
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetimagereferenceforvalue
|
|
587
|
+
public static PSGetImageReferenceForValue(propkey: REFPROPERTYKEY, propvar: REFPROPVARIANT, ppszImageRes: LPPWSTR): HRESULT {
|
|
588
|
+
return Propsys.Load('PSGetImageReferenceForValue')(propkey, propvar, ppszImageRes);
|
|
589
|
+
}
|
|
590
|
+
|
|
591
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetitempropertyhandler
|
|
592
|
+
public static PSGetItemPropertyHandler(punkItem: IUnknown, fReadWrite: BOOL, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
593
|
+
return Propsys.Load('PSGetItemPropertyHandler')(punkItem, fReadWrite, riid, ppv);
|
|
594
|
+
}
|
|
595
|
+
|
|
596
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetitempropertyhandlerwithcreateobject
|
|
597
|
+
public static PSGetItemPropertyHandlerWithCreateObject(punkItem: IUnknown, fReadWrite: BOOL, punkCreateObject: IUnknown, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
598
|
+
return Propsys.Load('PSGetItemPropertyHandlerWithCreateObject')(punkItem, fReadWrite, punkCreateObject, riid, ppv);
|
|
599
|
+
}
|
|
600
|
+
|
|
601
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetnamefrompropertykey
|
|
602
|
+
public static PSGetNameFromPropertyKey(propkey: REFPROPERTYKEY, ppszCanonicalName: LPPWSTR): HRESULT {
|
|
603
|
+
return Propsys.Load('PSGetNameFromPropertyKey')(propkey, ppszCanonicalName);
|
|
604
|
+
}
|
|
605
|
+
|
|
606
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetnamedpropertyfrompropertystorage
|
|
607
|
+
public static PSGetNamedPropertyFromPropertyStorage(psps: PCUSERIALIZEDPROPSTORAGE, cb: DWORD, pszName: LPCWSTR, ppropvar: LPPROPVARIANT): HRESULT {
|
|
608
|
+
return Propsys.Load('PSGetNamedPropertyFromPropertyStorage')(psps, cb, pszName, ppropvar);
|
|
609
|
+
}
|
|
610
|
+
|
|
611
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetpropertydescription
|
|
612
|
+
public static PSGetPropertyDescription(propkey: REFPROPERTYKEY, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
613
|
+
return Propsys.Load('PSGetPropertyDescription')(propkey, riid, ppv);
|
|
614
|
+
}
|
|
615
|
+
|
|
616
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetpropertydescriptionbyname
|
|
617
|
+
public static PSGetPropertyDescriptionByName(pszCanonicalName: LPCWSTR, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
618
|
+
return Propsys.Load('PSGetPropertyDescriptionByName')(pszCanonicalName, riid, ppv);
|
|
619
|
+
}
|
|
620
|
+
|
|
621
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetpropertydescriptionlistfromstring
|
|
622
|
+
public static PSGetPropertyDescriptionListFromString(pszPropList: LPCWSTR, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
623
|
+
return Propsys.Load('PSGetPropertyDescriptionListFromString')(pszPropList, riid, ppv);
|
|
624
|
+
}
|
|
625
|
+
|
|
626
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetpropertyfrompropertystorage
|
|
627
|
+
public static PSGetPropertyFromPropertyStorage(psps: PCUSERIALIZEDPROPSTORAGE, cb: DWORD, rpkey: REFPROPERTYKEY, ppropvar: LPPROPVARIANT): HRESULT {
|
|
628
|
+
return Propsys.Load('PSGetPropertyFromPropertyStorage')(psps, cb, rpkey, ppropvar);
|
|
629
|
+
}
|
|
630
|
+
|
|
631
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetpropertykeyfromname
|
|
632
|
+
public static PSGetPropertyKeyFromName(pszName: PCWSTR, ppropkey: LPPROPERTYKEY): HRESULT {
|
|
633
|
+
return Propsys.Load('PSGetPropertyKeyFromName')(pszName, ppropkey);
|
|
634
|
+
}
|
|
635
|
+
|
|
636
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetpropertysystem
|
|
637
|
+
public static PSGetPropertySystem(riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
638
|
+
return Propsys.Load('PSGetPropertySystem')(riid, ppv);
|
|
639
|
+
}
|
|
640
|
+
|
|
641
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psgetpropertyvalue
|
|
642
|
+
public static PSGetPropertyValue(pps: IPropertyStore, ppd: IPropertyDescription, ppropvar: LPPROPVARIANT): HRESULT {
|
|
643
|
+
return Propsys.Load('PSGetPropertyValue')(pps, ppd, ppropvar);
|
|
644
|
+
}
|
|
645
|
+
|
|
646
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pslookuppropertyhandlerclsid
|
|
647
|
+
public static PSLookupPropertyHandlerCLSID(pszFilePath: PCWSTR, pclsid: LPCLSID): HRESULT {
|
|
648
|
+
return Propsys.Load('PSLookupPropertyHandlerCLSID')(pszFilePath, pclsid);
|
|
649
|
+
}
|
|
650
|
+
|
|
651
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_delete
|
|
652
|
+
public static PSPropertyBag_Delete(propBag: IPropertyBag, propName: LPCWSTR): HRESULT {
|
|
653
|
+
return Propsys.Load('PSPropertyBag_Delete')(propBag, propName);
|
|
654
|
+
}
|
|
655
|
+
|
|
656
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readbool
|
|
657
|
+
public static PSPropertyBag_ReadBOOL(propBag: IPropertyBag, propName: LPCWSTR, value: LPBOOL): HRESULT {
|
|
658
|
+
return Propsys.Load('PSPropertyBag_ReadBOOL')(propBag, propName, value);
|
|
659
|
+
}
|
|
660
|
+
|
|
661
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readbstr
|
|
662
|
+
public static PSPropertyBag_ReadBSTR(propBag: IPropertyBag, propName: LPCWSTR, value: LPBSTR): HRESULT {
|
|
663
|
+
return Propsys.Load('PSPropertyBag_ReadBSTR')(propBag, propName, value);
|
|
664
|
+
}
|
|
665
|
+
|
|
666
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readdword
|
|
667
|
+
public static PSPropertyBag_ReadDWORD(propBag: IPropertyBag, propName: LPCWSTR, value: LPDWORD): HRESULT {
|
|
668
|
+
return Propsys.Load('PSPropertyBag_ReadDWORD')(propBag, propName, value);
|
|
669
|
+
}
|
|
670
|
+
|
|
671
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readguid
|
|
672
|
+
public static PSPropertyBag_ReadGUID(propBag: IPropertyBag, propName: LPCWSTR, value: LPGUID): HRESULT {
|
|
673
|
+
return Propsys.Load('PSPropertyBag_ReadGUID')(propBag, propName, value);
|
|
674
|
+
}
|
|
675
|
+
|
|
676
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readint
|
|
677
|
+
public static PSPropertyBag_ReadInt(propBag: IPropertyBag, propName: LPCWSTR, value: LPINT): HRESULT {
|
|
678
|
+
return Propsys.Load('PSPropertyBag_ReadInt')(propBag, propName, value);
|
|
679
|
+
}
|
|
680
|
+
|
|
681
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readlong
|
|
682
|
+
public static PSPropertyBag_ReadLONG(propBag: IPropertyBag, propName: LPCWSTR, value: LPLONG): HRESULT {
|
|
683
|
+
return Propsys.Load('PSPropertyBag_ReadLONG')(propBag, propName, value);
|
|
684
|
+
}
|
|
685
|
+
|
|
686
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readpointl
|
|
687
|
+
public static PSPropertyBag_ReadPOINTL(propBag: IPropertyBag, propName: LPCWSTR, value: LPPOINTL): HRESULT {
|
|
688
|
+
return Propsys.Load('PSPropertyBag_ReadPOINTL')(propBag, propName, value);
|
|
689
|
+
}
|
|
690
|
+
|
|
691
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readpoints
|
|
692
|
+
public static PSPropertyBag_ReadPOINTS(propBag: IPropertyBag, propName: LPCWSTR, value: LPPOINTS): HRESULT {
|
|
693
|
+
return Propsys.Load('PSPropertyBag_ReadPOINTS')(propBag, propName, value);
|
|
694
|
+
}
|
|
695
|
+
|
|
696
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readpropertykey
|
|
697
|
+
public static PSPropertyBag_ReadPropertyKey(propBag: IPropertyBag, propName: LPCWSTR, value: LPPROPERTYKEY): HRESULT {
|
|
698
|
+
return Propsys.Load('PSPropertyBag_ReadPropertyKey')(propBag, propName, value);
|
|
699
|
+
}
|
|
700
|
+
|
|
701
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readrectl
|
|
702
|
+
public static PSPropertyBag_ReadRECTL(propBag: IPropertyBag, propName: LPCWSTR, value: LPRECTL): HRESULT {
|
|
703
|
+
return Propsys.Load('PSPropertyBag_ReadRECTL')(propBag, propName, value);
|
|
704
|
+
}
|
|
705
|
+
|
|
706
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readshort
|
|
707
|
+
public static PSPropertyBag_ReadSHORT(propBag: IPropertyBag, propName: LPCWSTR, value: LPSHORT): HRESULT {
|
|
708
|
+
return Propsys.Load('PSPropertyBag_ReadSHORT')(propBag, propName, value);
|
|
709
|
+
}
|
|
710
|
+
|
|
711
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readstr
|
|
712
|
+
public static PSPropertyBag_ReadStr(propBag: IPropertyBag, propName: LPCWSTR, value: LPWSTR, characterCount: INT): HRESULT {
|
|
713
|
+
return Propsys.Load('PSPropertyBag_ReadStr')(propBag, propName, value, characterCount);
|
|
714
|
+
}
|
|
715
|
+
|
|
716
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readstralloc
|
|
717
|
+
public static PSPropertyBag_ReadStrAlloc(propBag: IPropertyBag, propName: LPCWSTR, value: LPPWSTR): HRESULT {
|
|
718
|
+
return Propsys.Load('PSPropertyBag_ReadStrAlloc')(propBag, propName, value);
|
|
719
|
+
}
|
|
720
|
+
|
|
721
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readstream
|
|
722
|
+
public static PSPropertyBag_ReadStream(propBag: IPropertyBag, propName: LPCWSTR, value: LPSTREAM): HRESULT {
|
|
723
|
+
return Propsys.Load('PSPropertyBag_ReadStream')(propBag, propName, value);
|
|
724
|
+
}
|
|
725
|
+
|
|
726
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readtype
|
|
727
|
+
public static PSPropertyBag_ReadType(propBag: IPropertyBag, propName: LPCWSTR, var_: LPVARIANT, type: VARTYPE): HRESULT {
|
|
728
|
+
return Propsys.Load('PSPropertyBag_ReadType')(propBag, propName, var_, type);
|
|
729
|
+
}
|
|
730
|
+
|
|
731
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readulonglong
|
|
732
|
+
public static PSPropertyBag_ReadULONGLONG(propBag: IPropertyBag, propName: LPCWSTR, value: LPULONGLONG): HRESULT {
|
|
733
|
+
return Propsys.Load('PSPropertyBag_ReadULONGLONG')(propBag, propName, value);
|
|
734
|
+
}
|
|
735
|
+
|
|
736
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_readunknown
|
|
737
|
+
public static PSPropertyBag_ReadUnknown(propBag: IPropertyBag, propName: LPCWSTR, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
738
|
+
return Propsys.Load('PSPropertyBag_ReadUnknown')(propBag, propName, riid, ppv);
|
|
739
|
+
}
|
|
740
|
+
|
|
741
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writebool
|
|
742
|
+
public static PSPropertyBag_WriteBOOL(propBag: IPropertyBag, propName: LPCWSTR, value: BOOL): HRESULT {
|
|
743
|
+
return Propsys.Load('PSPropertyBag_WriteBOOL')(propBag, propName, value);
|
|
744
|
+
}
|
|
745
|
+
|
|
746
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writebstr
|
|
747
|
+
public static PSPropertyBag_WriteBSTR(propBag: IPropertyBag, propName: LPCWSTR, value: BSTR): HRESULT {
|
|
748
|
+
return Propsys.Load('PSPropertyBag_WriteBSTR')(propBag, propName, value);
|
|
749
|
+
}
|
|
750
|
+
|
|
751
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writedword
|
|
752
|
+
public static PSPropertyBag_WriteDWORD(propBag: IPropertyBag, propName: LPCWSTR, value: DWORD): HRESULT {
|
|
753
|
+
return Propsys.Load('PSPropertyBag_WriteDWORD')(propBag, propName, value);
|
|
754
|
+
}
|
|
755
|
+
|
|
756
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writeguid
|
|
757
|
+
public static PSPropertyBag_WriteGUID(propBag: IPropertyBag, propName: LPCWSTR, value: LPGUID): HRESULT {
|
|
758
|
+
return Propsys.Load('PSPropertyBag_WriteGUID')(propBag, propName, value);
|
|
759
|
+
}
|
|
760
|
+
|
|
761
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writeint
|
|
762
|
+
public static PSPropertyBag_WriteInt(propBag: IPropertyBag, propName: LPCWSTR, value: INT): HRESULT {
|
|
763
|
+
return Propsys.Load('PSPropertyBag_WriteInt')(propBag, propName, value);
|
|
764
|
+
}
|
|
765
|
+
|
|
766
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writelong
|
|
767
|
+
public static PSPropertyBag_WriteLONG(propBag: IPropertyBag, propName: LPCWSTR, value: LONG): HRESULT {
|
|
768
|
+
return Propsys.Load('PSPropertyBag_WriteLONG')(propBag, propName, value);
|
|
769
|
+
}
|
|
770
|
+
|
|
771
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writepointl
|
|
772
|
+
public static PSPropertyBag_WritePOINTL(propBag: IPropertyBag, propName: LPCWSTR, value: LPPOINTL): HRESULT {
|
|
773
|
+
return Propsys.Load('PSPropertyBag_WritePOINTL')(propBag, propName, value);
|
|
774
|
+
}
|
|
775
|
+
|
|
776
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writepoints
|
|
777
|
+
public static PSPropertyBag_WritePOINTS(propBag: IPropertyBag, propName: LPCWSTR, value: LPPOINTS): HRESULT {
|
|
778
|
+
return Propsys.Load('PSPropertyBag_WritePOINTS')(propBag, propName, value);
|
|
779
|
+
}
|
|
780
|
+
|
|
781
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writepropertykey
|
|
782
|
+
public static PSPropertyBag_WritePropertyKey(propBag: IPropertyBag, propName: LPCWSTR, value: REFPROPERTYKEY): HRESULT {
|
|
783
|
+
return Propsys.Load('PSPropertyBag_WritePropertyKey')(propBag, propName, value);
|
|
784
|
+
}
|
|
785
|
+
|
|
786
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writerectl
|
|
787
|
+
public static PSPropertyBag_WriteRECTL(propBag: IPropertyBag, propName: LPCWSTR, value: LPRECTL): HRESULT {
|
|
788
|
+
return Propsys.Load('PSPropertyBag_WriteRECTL')(propBag, propName, value);
|
|
789
|
+
}
|
|
790
|
+
|
|
791
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writeshort
|
|
792
|
+
public static PSPropertyBag_WriteSHORT(propBag: IPropertyBag, propName: LPCWSTR, value: SHORT): HRESULT {
|
|
793
|
+
return Propsys.Load('PSPropertyBag_WriteSHORT')(propBag, propName, value);
|
|
794
|
+
}
|
|
795
|
+
|
|
796
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writestr
|
|
797
|
+
public static PSPropertyBag_WriteStr(propBag: IPropertyBag, propName: LPCWSTR, value: LPCWSTR): HRESULT {
|
|
798
|
+
return Propsys.Load('PSPropertyBag_WriteStr')(propBag, propName, value);
|
|
799
|
+
}
|
|
800
|
+
|
|
801
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writestream
|
|
802
|
+
public static PSPropertyBag_WriteStream(propBag: IPropertyBag, propName: LPCWSTR, value: IStream): HRESULT {
|
|
803
|
+
return Propsys.Load('PSPropertyBag_WriteStream')(propBag, propName, value);
|
|
804
|
+
}
|
|
805
|
+
|
|
806
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writeulonglong
|
|
807
|
+
public static PSPropertyBag_WriteULONGLONG(propBag: IPropertyBag, propName: LPCWSTR, value: ULONGLONG): HRESULT {
|
|
808
|
+
return Propsys.Load('PSPropertyBag_WriteULONGLONG')(propBag, propName, value);
|
|
809
|
+
}
|
|
810
|
+
|
|
811
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertybag_writeunknown
|
|
812
|
+
public static PSPropertyBag_WriteUnknown(propBag: IPropertyBag, propName: LPCWSTR, punk: IUnknown): HRESULT {
|
|
813
|
+
return Propsys.Load('PSPropertyBag_WriteUnknown')(propBag, propName, punk);
|
|
814
|
+
}
|
|
815
|
+
|
|
816
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pspropertykeyfromstring
|
|
817
|
+
public static PSPropertyKeyFromString(pszString: LPCWSTR, pkey: LPPROPERTYKEY): HRESULT {
|
|
818
|
+
return Propsys.Load('PSPropertyKeyFromString')(pszString, pkey);
|
|
819
|
+
}
|
|
820
|
+
|
|
821
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psrefreshpropertyschema
|
|
822
|
+
public static PSRefreshPropertySchema(): HRESULT {
|
|
823
|
+
return Propsys.Load('PSRefreshPropertySchema')();
|
|
824
|
+
}
|
|
825
|
+
|
|
826
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psregisterpropertyschema
|
|
827
|
+
public static PSRegisterPropertySchema(pszPath: PCWSTR): HRESULT {
|
|
828
|
+
return Propsys.Load('PSRegisterPropertySchema')(pszPath);
|
|
829
|
+
}
|
|
830
|
+
|
|
831
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-pssetpropertyvalue
|
|
832
|
+
public static PSSetPropertyValue(pps: IPropertyStore, ppd: IPropertyDescription, propvar: REFPROPVARIANT): HRESULT {
|
|
833
|
+
return Propsys.Load('PSSetPropertyValue')(pps, ppd, propvar);
|
|
834
|
+
}
|
|
835
|
+
|
|
836
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psstringfrompropertykey
|
|
837
|
+
public static PSStringFromPropertyKey(pkey: REFPROPERTYKEY, psz: LPWSTR, cch: UINT): HRESULT {
|
|
838
|
+
return Propsys.Load('PSStringFromPropertyKey')(pkey, psz, cch);
|
|
839
|
+
}
|
|
840
|
+
|
|
841
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-psunregisterpropertyschema
|
|
842
|
+
public static PSUnregisterPropertySchema(pszPath: PCWSTR): HRESULT {
|
|
843
|
+
return Propsys.Load('PSUnregisterPropertySchema')(pszPath);
|
|
844
|
+
}
|
|
845
|
+
|
|
846
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantchangetype
|
|
847
|
+
public static PropVariantChangeType(ppropvarDest: LPPROPVARIANT, propvarSrc: REFPROPVARIANT, flags: PROPVAR_CHANGE_FLAGS, vt: VARTYPE): HRESULT {
|
|
848
|
+
return Propsys.Load('PropVariantChangeType')(ppropvarDest, propvarSrc, flags, vt);
|
|
849
|
+
}
|
|
850
|
+
|
|
851
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantcompareex
|
|
852
|
+
public static PropVariantCompareEx(propvar1: REFPROPVARIANT, propvar2: REFPROPVARIANT, unit: PROPVAR_COMPARE_UNIT, flags: PROPVAR_COMPARE_FLAGS): INT {
|
|
853
|
+
return Propsys.Load('PropVariantCompareEx')(propvar1, propvar2, unit, flags);
|
|
854
|
+
}
|
|
855
|
+
|
|
856
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantgetbooleanelem
|
|
857
|
+
public static PropVariantGetBooleanElem(propvar: REFPROPVARIANT, iElem: ULONG, pfVal: LPBOOL): HRESULT {
|
|
858
|
+
return Propsys.Load('PropVariantGetBooleanElem')(propvar, iElem, pfVal);
|
|
859
|
+
}
|
|
860
|
+
|
|
861
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantgetdoubleelem
|
|
862
|
+
public static PropVariantGetDoubleElem(propvar: REFPROPVARIANT, iElem: ULONG, pnVal: LPDOUBLE): HRESULT {
|
|
863
|
+
return Propsys.Load('PropVariantGetDoubleElem')(propvar, iElem, pnVal);
|
|
864
|
+
}
|
|
865
|
+
|
|
866
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantgetelementcount
|
|
867
|
+
public static PropVariantGetElementCount(propvar: REFPROPVARIANT): ULONG {
|
|
868
|
+
return Propsys.Load('PropVariantGetElementCount')(propvar);
|
|
869
|
+
}
|
|
870
|
+
|
|
871
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantgetfiletimeelem
|
|
872
|
+
public static PropVariantGetFileTimeElem(propvar: REFPROPVARIANT, iElem: ULONG, pftVal: LPFILETIME): HRESULT {
|
|
873
|
+
return Propsys.Load('PropVariantGetFileTimeElem')(propvar, iElem, pftVal);
|
|
874
|
+
}
|
|
875
|
+
|
|
876
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantgetint16elem
|
|
877
|
+
public static PropVariantGetInt16Elem(propvar: REFPROPVARIANT, iElem: ULONG, pnVal: LPSHORT): HRESULT {
|
|
878
|
+
return Propsys.Load('PropVariantGetInt16Elem')(propvar, iElem, pnVal);
|
|
879
|
+
}
|
|
880
|
+
|
|
881
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantgetint32elem
|
|
882
|
+
public static PropVariantGetInt32Elem(propvar: REFPROPVARIANT, iElem: ULONG, pnVal: LPLONG): HRESULT {
|
|
883
|
+
return Propsys.Load('PropVariantGetInt32Elem')(propvar, iElem, pnVal);
|
|
884
|
+
}
|
|
885
|
+
|
|
886
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantgetint64elem
|
|
887
|
+
public static PropVariantGetInt64Elem(propvar: REFPROPVARIANT, iElem: ULONG, pnVal: LPLONGLONG): HRESULT {
|
|
888
|
+
return Propsys.Load('PropVariantGetInt64Elem')(propvar, iElem, pnVal);
|
|
889
|
+
}
|
|
890
|
+
|
|
891
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantgetstringelem
|
|
892
|
+
public static PropVariantGetStringElem(propvar: REFPROPVARIANT, iElem: ULONG, ppszVal: LPPWSTR): HRESULT {
|
|
893
|
+
return Propsys.Load('PropVariantGetStringElem')(propvar, iElem, ppszVal);
|
|
894
|
+
}
|
|
895
|
+
|
|
896
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantgetuint16elem
|
|
897
|
+
public static PropVariantGetUInt16Elem(propvar: REFPROPVARIANT, iElem: ULONG, pnVal: LPUSHORT): HRESULT {
|
|
898
|
+
return Propsys.Load('PropVariantGetUInt16Elem')(propvar, iElem, pnVal);
|
|
899
|
+
}
|
|
900
|
+
|
|
901
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantgetuint32elem
|
|
902
|
+
public static PropVariantGetUInt32Elem(propvar: REFPROPVARIANT, iElem: ULONG, pnVal: LPULONG): HRESULT {
|
|
903
|
+
return Propsys.Load('PropVariantGetUInt32Elem')(propvar, iElem, pnVal);
|
|
904
|
+
}
|
|
905
|
+
|
|
906
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvariantgetuint64elem
|
|
907
|
+
public static PropVariantGetUInt64Elem(propvar: REFPROPVARIANT, iElem: ULONG, pnVal: LPULONGLONG): HRESULT {
|
|
908
|
+
return Propsys.Load('PropVariantGetUInt64Elem')(propvar, iElem, pnVal);
|
|
909
|
+
}
|
|
910
|
+
|
|
911
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttobstr
|
|
912
|
+
public static PropVariantToBSTR(propvar: REFPROPVARIANT, pbstrOut: LPBSTR): HRESULT {
|
|
913
|
+
return Propsys.Load('PropVariantToBSTR')(propvar, pbstrOut);
|
|
914
|
+
}
|
|
915
|
+
|
|
916
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoboolean
|
|
917
|
+
public static PropVariantToBoolean(propvarIn: REFPROPVARIANT, pfRet: LPBOOL): HRESULT {
|
|
918
|
+
return Propsys.Load('PropVariantToBoolean')(propvarIn, pfRet);
|
|
919
|
+
}
|
|
920
|
+
|
|
921
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttobooleanvector
|
|
922
|
+
public static PropVariantToBooleanVector(propvar: REFPROPVARIANT, prgf: LPBOOL, crgf: ULONG, pcElem: LPULONG): HRESULT {
|
|
923
|
+
return Propsys.Load('PropVariantToBooleanVector')(propvar, prgf, crgf, pcElem);
|
|
924
|
+
}
|
|
925
|
+
|
|
926
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttobooleanvectoralloc
|
|
927
|
+
public static PropVariantToBooleanVectorAlloc(propvar: REFPROPVARIANT, pprgf: LPLPBOOL, pcElem: LPULONG): HRESULT {
|
|
928
|
+
return Propsys.Load('PropVariantToBooleanVectorAlloc')(propvar, pprgf, pcElem);
|
|
929
|
+
}
|
|
930
|
+
|
|
931
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttobooleanwithdefault
|
|
932
|
+
public static PropVariantToBooleanWithDefault(propvarIn: REFPROPVARIANT, fDefault: BOOL): BOOL {
|
|
933
|
+
return Propsys.Load('PropVariantToBooleanWithDefault')(propvarIn, fDefault);
|
|
934
|
+
}
|
|
935
|
+
|
|
936
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttobuffer
|
|
937
|
+
public static PropVariantToBuffer(propvar: REFPROPVARIANT, pv: LPVOID, cb: UINT): HRESULT {
|
|
938
|
+
return Propsys.Load('PropVariantToBuffer')(propvar, pv, cb);
|
|
939
|
+
}
|
|
940
|
+
|
|
941
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttodouble
|
|
942
|
+
public static PropVariantToDouble(propvarIn: REFPROPVARIANT, pdblRet: LPDOUBLE): HRESULT {
|
|
943
|
+
return Propsys.Load('PropVariantToDouble')(propvarIn, pdblRet);
|
|
944
|
+
}
|
|
945
|
+
|
|
946
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttodoublevector
|
|
947
|
+
public static PropVariantToDoubleVector(propvar: REFPROPVARIANT, prgn: LPDOUBLE, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
948
|
+
return Propsys.Load('PropVariantToDoubleVector')(propvar, prgn, crgn, pcElem);
|
|
949
|
+
}
|
|
950
|
+
|
|
951
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttodoublevectoralloc
|
|
952
|
+
public static PropVariantToDoubleVectorAlloc(propvar: REFPROPVARIANT, pprgn: LPLPDOUBLE, pcElem: LPULONG): HRESULT {
|
|
953
|
+
return Propsys.Load('PropVariantToDoubleVectorAlloc')(propvar, pprgn, pcElem);
|
|
954
|
+
}
|
|
955
|
+
|
|
956
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttodoublewithdefault
|
|
957
|
+
public static PropVariantToDoubleWithDefault(propvarIn: REFPROPVARIANT, dblDefault: DOUBLE): DOUBLE {
|
|
958
|
+
return Propsys.Load('PropVariantToDoubleWithDefault')(propvarIn, dblDefault);
|
|
959
|
+
}
|
|
960
|
+
|
|
961
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttofiletime
|
|
962
|
+
public static PropVariantToFileTime(propvar: REFPROPVARIANT, pstfOut: PSTIME_FLAGS, pftOut: LPFILETIME): HRESULT {
|
|
963
|
+
return Propsys.Load('PropVariantToFileTime')(propvar, pstfOut, pftOut);
|
|
964
|
+
}
|
|
965
|
+
|
|
966
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttofiletimevector
|
|
967
|
+
public static PropVariantToFileTimeVector(propvar: REFPROPVARIANT, prgft: LPFILETIME, crgft: ULONG, pcElem: LPULONG): HRESULT {
|
|
968
|
+
return Propsys.Load('PropVariantToFileTimeVector')(propvar, prgft, crgft, pcElem);
|
|
969
|
+
}
|
|
970
|
+
|
|
971
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttofiletimevectoralloc
|
|
972
|
+
public static PropVariantToFileTimeVectorAlloc(propvar: REFPROPVARIANT, pprgft: LPLPFILETIME, pcElem: LPULONG): HRESULT {
|
|
973
|
+
return Propsys.Load('PropVariantToFileTimeVectorAlloc')(propvar, pprgft, pcElem);
|
|
974
|
+
}
|
|
975
|
+
|
|
976
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoguid
|
|
977
|
+
public static PropVariantToGUID(propvar: REFPROPVARIANT, pguid: LPGUID): HRESULT {
|
|
978
|
+
return Propsys.Load('PropVariantToGUID')(propvar, pguid);
|
|
979
|
+
}
|
|
980
|
+
|
|
981
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint16
|
|
982
|
+
public static PropVariantToInt16(propvarIn: REFPROPVARIANT, piRet: LPSHORT): HRESULT {
|
|
983
|
+
return Propsys.Load('PropVariantToInt16')(propvarIn, piRet);
|
|
984
|
+
}
|
|
985
|
+
|
|
986
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint16vector
|
|
987
|
+
public static PropVariantToInt16Vector(propvar: REFPROPVARIANT, prgn: LPSHORT, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
988
|
+
return Propsys.Load('PropVariantToInt16Vector')(propvar, prgn, crgn, pcElem);
|
|
989
|
+
}
|
|
990
|
+
|
|
991
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint16vectoralloc
|
|
992
|
+
public static PropVariantToInt16VectorAlloc(propvar: REFPROPVARIANT, pprgn: LPLPSHORT, pcElem: LPULONG): HRESULT {
|
|
993
|
+
return Propsys.Load('PropVariantToInt16VectorAlloc')(propvar, pprgn, pcElem);
|
|
994
|
+
}
|
|
995
|
+
|
|
996
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint16withdefault
|
|
997
|
+
public static PropVariantToInt16WithDefault(propvarIn: REFPROPVARIANT, iDefault: SHORT): SHORT {
|
|
998
|
+
return Propsys.Load('PropVariantToInt16WithDefault')(propvarIn, iDefault);
|
|
999
|
+
}
|
|
1000
|
+
|
|
1001
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint32
|
|
1002
|
+
public static PropVariantToInt32(propvarIn: REFPROPVARIANT, plRet: LPLONG): HRESULT {
|
|
1003
|
+
return Propsys.Load('PropVariantToInt32')(propvarIn, plRet);
|
|
1004
|
+
}
|
|
1005
|
+
|
|
1006
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint32vector
|
|
1007
|
+
public static PropVariantToInt32Vector(propvar: REFPROPVARIANT, prgn: LPLONG, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1008
|
+
return Propsys.Load('PropVariantToInt32Vector')(propvar, prgn, crgn, pcElem);
|
|
1009
|
+
}
|
|
1010
|
+
|
|
1011
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint32vectoralloc
|
|
1012
|
+
public static PropVariantToInt32VectorAlloc(propvar: REFPROPVARIANT, pprgn: LPLPLONG, pcElem: LPULONG): HRESULT {
|
|
1013
|
+
return Propsys.Load('PropVariantToInt32VectorAlloc')(propvar, pprgn, pcElem);
|
|
1014
|
+
}
|
|
1015
|
+
|
|
1016
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint32withdefault
|
|
1017
|
+
public static PropVariantToInt32WithDefault(propvarIn: REFPROPVARIANT, lDefault: LONG): LONG {
|
|
1018
|
+
return Propsys.Load('PropVariantToInt32WithDefault')(propvarIn, lDefault);
|
|
1019
|
+
}
|
|
1020
|
+
|
|
1021
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint64
|
|
1022
|
+
public static PropVariantToInt64(propvarIn: REFPROPVARIANT, pllRet: LPLONGLONG): HRESULT {
|
|
1023
|
+
return Propsys.Load('PropVariantToInt64')(propvarIn, pllRet);
|
|
1024
|
+
}
|
|
1025
|
+
|
|
1026
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint64vector
|
|
1027
|
+
public static PropVariantToInt64Vector(propvar: REFPROPVARIANT, prgn: LPLONGLONG, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1028
|
+
return Propsys.Load('PropVariantToInt64Vector')(propvar, prgn, crgn, pcElem);
|
|
1029
|
+
}
|
|
1030
|
+
|
|
1031
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint64vectoralloc
|
|
1032
|
+
public static PropVariantToInt64VectorAlloc(propvar: REFPROPVARIANT, pprgn: LPLPLONGLONG, pcElem: LPULONG): HRESULT {
|
|
1033
|
+
return Propsys.Load('PropVariantToInt64VectorAlloc')(propvar, pprgn, pcElem);
|
|
1034
|
+
}
|
|
1035
|
+
|
|
1036
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttoint64withdefault
|
|
1037
|
+
public static PropVariantToInt64WithDefault(propvarIn: REFPROPVARIANT, llDefault: LONGLONG): LONGLONG {
|
|
1038
|
+
return Propsys.Load('PropVariantToInt64WithDefault')(propvarIn, llDefault);
|
|
1039
|
+
}
|
|
1040
|
+
|
|
1041
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttostrret
|
|
1042
|
+
public static PropVariantToStrRet(propvar: REFPROPVARIANT, pstrret: LPSTRRET): HRESULT {
|
|
1043
|
+
return Propsys.Load('PropVariantToStrRet')(propvar, pstrret);
|
|
1044
|
+
}
|
|
1045
|
+
|
|
1046
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttostring
|
|
1047
|
+
public static PropVariantToString(propvar: REFPROPVARIANT, psz: PWSTR, cch: UINT): HRESULT {
|
|
1048
|
+
return Propsys.Load('PropVariantToString')(propvar, psz, cch);
|
|
1049
|
+
}
|
|
1050
|
+
|
|
1051
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttostringalloc
|
|
1052
|
+
public static PropVariantToStringAlloc(propvar: REFPROPVARIANT, ppszOut: LPPWSTR): HRESULT {
|
|
1053
|
+
return Propsys.Load('PropVariantToStringAlloc')(propvar, ppszOut);
|
|
1054
|
+
}
|
|
1055
|
+
|
|
1056
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttostringvector
|
|
1057
|
+
public static PropVariantToStringVector(propvar: REFPROPVARIANT, prgsz: LPPWSTR, crgsz: ULONG, pcElem: LPULONG): HRESULT {
|
|
1058
|
+
return Propsys.Load('PropVariantToStringVector')(propvar, prgsz, crgsz, pcElem);
|
|
1059
|
+
}
|
|
1060
|
+
|
|
1061
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttostringvectoralloc
|
|
1062
|
+
public static PropVariantToStringVectorAlloc(propvar: REFPROPVARIANT, pprgsz: LPLPPWSTR, pcElem: LPULONG): HRESULT {
|
|
1063
|
+
return Propsys.Load('PropVariantToStringVectorAlloc')(propvar, pprgsz, pcElem);
|
|
1064
|
+
}
|
|
1065
|
+
|
|
1066
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttostringwithdefault
|
|
1067
|
+
public static PropVariantToStringWithDefault(propvarIn: REFPROPVARIANT, pszDefault: LPCWSTR | NULL): PCWSTR {
|
|
1068
|
+
return Propsys.Load('PropVariantToStringWithDefault')(propvarIn, pszDefault);
|
|
1069
|
+
}
|
|
1070
|
+
|
|
1071
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint16
|
|
1072
|
+
public static PropVariantToUInt16(propvarIn: REFPROPVARIANT, puiRet: LPUSHORT): HRESULT {
|
|
1073
|
+
return Propsys.Load('PropVariantToUInt16')(propvarIn, puiRet);
|
|
1074
|
+
}
|
|
1075
|
+
|
|
1076
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint16vector
|
|
1077
|
+
public static PropVariantToUInt16Vector(propvar: REFPROPVARIANT, prgn: LPUSHORT, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1078
|
+
return Propsys.Load('PropVariantToUInt16Vector')(propvar, prgn, crgn, pcElem);
|
|
1079
|
+
}
|
|
1080
|
+
|
|
1081
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint16vectoralloc
|
|
1082
|
+
public static PropVariantToUInt16VectorAlloc(propvar: REFPROPVARIANT, pprgn: LPLPUSHORT, pcElem: LPULONG): HRESULT {
|
|
1083
|
+
return Propsys.Load('PropVariantToUInt16VectorAlloc')(propvar, pprgn, pcElem);
|
|
1084
|
+
}
|
|
1085
|
+
|
|
1086
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint16withdefault
|
|
1087
|
+
public static PropVariantToUInt16WithDefault(propvarIn: REFPROPVARIANT, uiDefault: USHORT): USHORT {
|
|
1088
|
+
return Propsys.Load('PropVariantToUInt16WithDefault')(propvarIn, uiDefault);
|
|
1089
|
+
}
|
|
1090
|
+
|
|
1091
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint32
|
|
1092
|
+
public static PropVariantToUInt32(propvarIn: REFPROPVARIANT, pulRet: LPULONG): HRESULT {
|
|
1093
|
+
return Propsys.Load('PropVariantToUInt32')(propvarIn, pulRet);
|
|
1094
|
+
}
|
|
1095
|
+
|
|
1096
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint32vector
|
|
1097
|
+
public static PropVariantToUInt32Vector(propvar: REFPROPVARIANT, prgn: LPULONG, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1098
|
+
return Propsys.Load('PropVariantToUInt32Vector')(propvar, prgn, crgn, pcElem);
|
|
1099
|
+
}
|
|
1100
|
+
|
|
1101
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint32vectoralloc
|
|
1102
|
+
public static PropVariantToUInt32VectorAlloc(propvar: REFPROPVARIANT, pprgn: LPLPULONG, pcElem: LPULONG): HRESULT {
|
|
1103
|
+
return Propsys.Load('PropVariantToUInt32VectorAlloc')(propvar, pprgn, pcElem);
|
|
1104
|
+
}
|
|
1105
|
+
|
|
1106
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint32withdefault
|
|
1107
|
+
public static PropVariantToUInt32WithDefault(propvarIn: REFPROPVARIANT, ulDefault: ULONG): ULONG {
|
|
1108
|
+
return Propsys.Load('PropVariantToUInt32WithDefault')(propvarIn, ulDefault);
|
|
1109
|
+
}
|
|
1110
|
+
|
|
1111
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint64
|
|
1112
|
+
public static PropVariantToUInt64(propvarIn: REFPROPVARIANT, pullRet: LPULONGLONG): HRESULT {
|
|
1113
|
+
return Propsys.Load('PropVariantToUInt64')(propvarIn, pullRet);
|
|
1114
|
+
}
|
|
1115
|
+
|
|
1116
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint64vector
|
|
1117
|
+
public static PropVariantToUInt64Vector(propvar: REFPROPVARIANT, prgn: LPULONGLONG, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1118
|
+
return Propsys.Load('PropVariantToUInt64Vector')(propvar, prgn, crgn, pcElem);
|
|
1119
|
+
}
|
|
1120
|
+
|
|
1121
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint64vectoralloc
|
|
1122
|
+
public static PropVariantToUInt64VectorAlloc(propvar: REFPROPVARIANT, pprgn: LPLPULONGLONG, pcElem: LPULONG): HRESULT {
|
|
1123
|
+
return Propsys.Load('PropVariantToUInt64VectorAlloc')(propvar, pprgn, pcElem);
|
|
1124
|
+
}
|
|
1125
|
+
|
|
1126
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttouint64withdefault
|
|
1127
|
+
public static PropVariantToUInt64WithDefault(propvarIn: REFPROPVARIANT, ullDefault: ULONGLONG): ULONGLONG {
|
|
1128
|
+
return Propsys.Load('PropVariantToUInt64WithDefault')(propvarIn, ullDefault);
|
|
1129
|
+
}
|
|
1130
|
+
|
|
1131
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-propvarianttovariant
|
|
1132
|
+
public static PropVariantToVariant(pPropVar: LPPROPVARIANT, pVar: LPVARIANT): HRESULT {
|
|
1133
|
+
return Propsys.Load('PropVariantToVariant')(pPropVar, pVar);
|
|
1134
|
+
}
|
|
1135
|
+
|
|
1136
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-propvarianttowinrtpropertyvalue
|
|
1137
|
+
public static PropVariantToWinRTPropertyValue(propvar: REFPROPVARIANT, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
1138
|
+
return Propsys.Load('PropVariantToWinRTPropertyValue')(propvar, riid, ppv);
|
|
1139
|
+
}
|
|
1140
|
+
|
|
1141
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shgetpropertystoreforwindow
|
|
1142
|
+
public static SHGetPropertyStoreForWindow(hwnd: HWND, riid: REFIID, ppv: LPLPVOID): HRESULT {
|
|
1143
|
+
return Propsys.Load('SHGetPropertyStoreForWindow')(hwnd, riid, ppv);
|
|
1144
|
+
}
|
|
1145
|
+
|
|
1146
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-stgdeserializepropvariant
|
|
1147
|
+
public static StgDeserializePropVariant(pprop: LPSERIALIZEDPROPERTYVALUE, cbMax: ULONG, ppropvar: LPPROPVARIANT): HRESULT {
|
|
1148
|
+
return Propsys.Load('StgDeserializePropVariant')(pprop, cbMax, ppropvar);
|
|
1149
|
+
}
|
|
1150
|
+
|
|
1151
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-stgserializepropvariant
|
|
1152
|
+
public static StgSerializePropVariant(ppropvar: LPPROPVARIANT, ppProp: LPLPSERIALIZEDPROPERTYVALUE, pcb: LPULONG): HRESULT {
|
|
1153
|
+
return Propsys.Load('StgSerializePropVariant')(ppropvar, ppProp, pcb);
|
|
1154
|
+
}
|
|
1155
|
+
|
|
1156
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-variantcompare
|
|
1157
|
+
public static VariantCompare(var1: REFVARIANT, var2: REFVARIANT): INT {
|
|
1158
|
+
return Propsys.Load('VariantCompare')(var1, var2);
|
|
1159
|
+
}
|
|
1160
|
+
|
|
1161
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-variantgetbooleanelem
|
|
1162
|
+
public static VariantGetBooleanElem(var_: REFVARIANT, iElem: ULONG, pfVal: LPBOOL): HRESULT {
|
|
1163
|
+
return Propsys.Load('VariantGetBooleanElem')(var_, iElem, pfVal);
|
|
1164
|
+
}
|
|
1165
|
+
|
|
1166
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-variantgetdoubleelem
|
|
1167
|
+
public static VariantGetDoubleElem(var_: REFVARIANT, iElem: ULONG, pnVal: LPDOUBLE): HRESULT {
|
|
1168
|
+
return Propsys.Load('VariantGetDoubleElem')(var_, iElem, pnVal);
|
|
1169
|
+
}
|
|
1170
|
+
|
|
1171
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-variantgetelementcount
|
|
1172
|
+
public static VariantGetElementCount(varIn: REFVARIANT): ULONG {
|
|
1173
|
+
return Propsys.Load('VariantGetElementCount')(varIn);
|
|
1174
|
+
}
|
|
1175
|
+
|
|
1176
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-variantgetint16elem
|
|
1177
|
+
public static VariantGetInt16Elem(var_: REFVARIANT, iElem: ULONG, pnVal: LPSHORT): HRESULT {
|
|
1178
|
+
return Propsys.Load('VariantGetInt16Elem')(var_, iElem, pnVal);
|
|
1179
|
+
}
|
|
1180
|
+
|
|
1181
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-variantgetint32elem
|
|
1182
|
+
public static VariantGetInt32Elem(var_: REFVARIANT, iElem: ULONG, pnVal: LPLONG): HRESULT {
|
|
1183
|
+
return Propsys.Load('VariantGetInt32Elem')(var_, iElem, pnVal);
|
|
1184
|
+
}
|
|
1185
|
+
|
|
1186
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-variantgetint64elem
|
|
1187
|
+
public static VariantGetInt64Elem(var_: REFVARIANT, iElem: ULONG, pnVal: LPLONGLONG): HRESULT {
|
|
1188
|
+
return Propsys.Load('VariantGetInt64Elem')(var_, iElem, pnVal);
|
|
1189
|
+
}
|
|
1190
|
+
|
|
1191
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-variantgetstringelem
|
|
1192
|
+
public static VariantGetStringElem(var_: REFVARIANT, iElem: ULONG, ppszVal: LPPWSTR): HRESULT {
|
|
1193
|
+
return Propsys.Load('VariantGetStringElem')(var_, iElem, ppszVal);
|
|
1194
|
+
}
|
|
1195
|
+
|
|
1196
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-variantgetuint16elem
|
|
1197
|
+
public static VariantGetUInt16Elem(var_: REFVARIANT, iElem: ULONG, pnVal: LPUSHORT): HRESULT {
|
|
1198
|
+
return Propsys.Load('VariantGetUInt16Elem')(var_, iElem, pnVal);
|
|
1199
|
+
}
|
|
1200
|
+
|
|
1201
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-variantgetuint32elem
|
|
1202
|
+
public static VariantGetUInt32Elem(var_: REFVARIANT, iElem: ULONG, pnVal: LPULONG): HRESULT {
|
|
1203
|
+
return Propsys.Load('VariantGetUInt32Elem')(var_, iElem, pnVal);
|
|
1204
|
+
}
|
|
1205
|
+
|
|
1206
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-variantgetuint64elem
|
|
1207
|
+
public static VariantGetUInt64Elem(var_: REFVARIANT, iElem: ULONG, pnVal: LPULONGLONG): HRESULT {
|
|
1208
|
+
return Propsys.Load('VariantGetUInt64Elem')(var_, iElem, pnVal);
|
|
1209
|
+
}
|
|
1210
|
+
|
|
1211
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoboolean
|
|
1212
|
+
public static VariantToBoolean(varIn: REFVARIANT, pfRet: LPBOOL): HRESULT {
|
|
1213
|
+
return Propsys.Load('VariantToBoolean')(varIn, pfRet);
|
|
1214
|
+
}
|
|
1215
|
+
|
|
1216
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttobooleanarray
|
|
1217
|
+
public static VariantToBooleanArray(var_: REFVARIANT, prgf: LPBOOL, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1218
|
+
return Propsys.Load('VariantToBooleanArray')(var_, prgf, crgn, pcElem);
|
|
1219
|
+
}
|
|
1220
|
+
|
|
1221
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttobooleanarrayalloc
|
|
1222
|
+
public static VariantToBooleanArrayAlloc(var_: REFVARIANT, pprgf: LPLPBOOL, pcElem: LPULONG): HRESULT {
|
|
1223
|
+
return Propsys.Load('VariantToBooleanArrayAlloc')(var_, pprgf, pcElem);
|
|
1224
|
+
}
|
|
1225
|
+
|
|
1226
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttobooleanwithdefault
|
|
1227
|
+
public static VariantToBooleanWithDefault(varIn: REFVARIANT, fDefault: BOOL): BOOL {
|
|
1228
|
+
return Propsys.Load('VariantToBooleanWithDefault')(varIn, fDefault);
|
|
1229
|
+
}
|
|
1230
|
+
|
|
1231
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttobuffer
|
|
1232
|
+
public static VariantToBuffer(varIn: REFVARIANT, pv: LPVOID, cb: UINT): HRESULT {
|
|
1233
|
+
return Propsys.Load('VariantToBuffer')(varIn, pv, cb);
|
|
1234
|
+
}
|
|
1235
|
+
|
|
1236
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttodosdatetime
|
|
1237
|
+
public static VariantToDosDateTime(varIn: REFVARIANT, pwDate: LPWORD, pwTime: LPWORD): HRESULT {
|
|
1238
|
+
return Propsys.Load('VariantToDosDateTime')(varIn, pwDate, pwTime);
|
|
1239
|
+
}
|
|
1240
|
+
|
|
1241
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttodouble
|
|
1242
|
+
public static VariantToDouble(varIn: REFVARIANT, pdblRet: LPDOUBLE): HRESULT {
|
|
1243
|
+
return Propsys.Load('VariantToDouble')(varIn, pdblRet);
|
|
1244
|
+
}
|
|
1245
|
+
|
|
1246
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttodoublearray
|
|
1247
|
+
public static VariantToDoubleArray(var_: REFVARIANT, prgn: LPDOUBLE, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1248
|
+
return Propsys.Load('VariantToDoubleArray')(var_, prgn, crgn, pcElem);
|
|
1249
|
+
}
|
|
1250
|
+
|
|
1251
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttodoublearrayalloc
|
|
1252
|
+
public static VariantToDoubleArrayAlloc(var_: REFVARIANT, pprgn: LPLPDOUBLE, pcElem: LPULONG): HRESULT {
|
|
1253
|
+
return Propsys.Load('VariantToDoubleArrayAlloc')(var_, pprgn, pcElem);
|
|
1254
|
+
}
|
|
1255
|
+
|
|
1256
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttodoublewithdefault
|
|
1257
|
+
public static VariantToDoubleWithDefault(varIn: REFVARIANT, dblDefault: DOUBLE): DOUBLE {
|
|
1258
|
+
return Propsys.Load('VariantToDoubleWithDefault')(varIn, dblDefault);
|
|
1259
|
+
}
|
|
1260
|
+
|
|
1261
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttofiletime
|
|
1262
|
+
public static VariantToFileTime(varIn: REFVARIANT, stfOut: PSTIME_FLAGS, pftOut: LPFILETIME): HRESULT {
|
|
1263
|
+
return Propsys.Load('VariantToFileTime')(varIn, stfOut, pftOut);
|
|
1264
|
+
}
|
|
1265
|
+
|
|
1266
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoguid
|
|
1267
|
+
public static VariantToGUID(varIn: REFVARIANT, pguid: LPGUID): HRESULT {
|
|
1268
|
+
return Propsys.Load('VariantToGUID')(varIn, pguid);
|
|
1269
|
+
}
|
|
1270
|
+
|
|
1271
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint16
|
|
1272
|
+
public static VariantToInt16(varIn: REFVARIANT, piRet: LPSHORT): HRESULT {
|
|
1273
|
+
return Propsys.Load('VariantToInt16')(varIn, piRet);
|
|
1274
|
+
}
|
|
1275
|
+
|
|
1276
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint16array
|
|
1277
|
+
public static VariantToInt16Array(var_: REFVARIANT, prgn: LPSHORT, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1278
|
+
return Propsys.Load('VariantToInt16Array')(var_, prgn, crgn, pcElem);
|
|
1279
|
+
}
|
|
1280
|
+
|
|
1281
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint16arrayalloc
|
|
1282
|
+
public static VariantToInt16ArrayAlloc(var_: REFVARIANT, pprgn: LPLPSHORT, pcElem: LPULONG): HRESULT {
|
|
1283
|
+
return Propsys.Load('VariantToInt16ArrayAlloc')(var_, pprgn, pcElem);
|
|
1284
|
+
}
|
|
1285
|
+
|
|
1286
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint16withdefault
|
|
1287
|
+
public static VariantToInt16WithDefault(varIn: REFVARIANT, iDefault: SHORT): SHORT {
|
|
1288
|
+
return Propsys.Load('VariantToInt16WithDefault')(varIn, iDefault);
|
|
1289
|
+
}
|
|
1290
|
+
|
|
1291
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint32
|
|
1292
|
+
public static VariantToInt32(varIn: REFVARIANT, plRet: LPLONG): HRESULT {
|
|
1293
|
+
return Propsys.Load('VariantToInt32')(varIn, plRet);
|
|
1294
|
+
}
|
|
1295
|
+
|
|
1296
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint32array
|
|
1297
|
+
public static VariantToInt32Array(var_: REFVARIANT, prgn: LPLONG, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1298
|
+
return Propsys.Load('VariantToInt32Array')(var_, prgn, crgn, pcElem);
|
|
1299
|
+
}
|
|
1300
|
+
|
|
1301
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint32arrayalloc
|
|
1302
|
+
public static VariantToInt32ArrayAlloc(var_: REFVARIANT, pprgn: LPLPLONG, pcElem: LPULONG): HRESULT {
|
|
1303
|
+
return Propsys.Load('VariantToInt32ArrayAlloc')(var_, pprgn, pcElem);
|
|
1304
|
+
}
|
|
1305
|
+
|
|
1306
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint32withdefault
|
|
1307
|
+
public static VariantToInt32WithDefault(varIn: REFVARIANT, lDefault: LONG): LONG {
|
|
1308
|
+
return Propsys.Load('VariantToInt32WithDefault')(varIn, lDefault);
|
|
1309
|
+
}
|
|
1310
|
+
|
|
1311
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint64
|
|
1312
|
+
public static VariantToInt64(varIn: REFVARIANT, pllRet: LPLONGLONG): HRESULT {
|
|
1313
|
+
return Propsys.Load('VariantToInt64')(varIn, pllRet);
|
|
1314
|
+
}
|
|
1315
|
+
|
|
1316
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint64array
|
|
1317
|
+
public static VariantToInt64Array(var_: REFVARIANT, prgn: LPLONGLONG, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1318
|
+
return Propsys.Load('VariantToInt64Array')(var_, prgn, crgn, pcElem);
|
|
1319
|
+
}
|
|
1320
|
+
|
|
1321
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint64arrayalloc
|
|
1322
|
+
public static VariantToInt64ArrayAlloc(var_: REFVARIANT, pprgn: LPLPLONGLONG, pcElem: LPULONG): HRESULT {
|
|
1323
|
+
return Propsys.Load('VariantToInt64ArrayAlloc')(var_, pprgn, pcElem);
|
|
1324
|
+
}
|
|
1325
|
+
|
|
1326
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttoint64withdefault
|
|
1327
|
+
public static VariantToInt64WithDefault(varIn: REFVARIANT, llDefault: LONGLONG): LONGLONG {
|
|
1328
|
+
return Propsys.Load('VariantToInt64WithDefault')(varIn, llDefault);
|
|
1329
|
+
}
|
|
1330
|
+
|
|
1331
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttopropvariant
|
|
1332
|
+
public static VariantToPropVariant(pVar: LPVARIANT, pPropVar: LPPROPVARIANT): HRESULT {
|
|
1333
|
+
return Propsys.Load('VariantToPropVariant')(pVar, pPropVar);
|
|
1334
|
+
}
|
|
1335
|
+
|
|
1336
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttostrret
|
|
1337
|
+
public static VariantToStrRet(varIn: REFVARIANT, pstrret: LPSTRRET): HRESULT {
|
|
1338
|
+
return Propsys.Load('VariantToStrRet')(varIn, pstrret);
|
|
1339
|
+
}
|
|
1340
|
+
|
|
1341
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttostring
|
|
1342
|
+
public static VariantToString(varIn: REFVARIANT, pszBuf: PWSTR, cchBuf: UINT): HRESULT {
|
|
1343
|
+
return Propsys.Load('VariantToString')(varIn, pszBuf, cchBuf);
|
|
1344
|
+
}
|
|
1345
|
+
|
|
1346
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttostringalloc
|
|
1347
|
+
public static VariantToStringAlloc(varIn: REFVARIANT, ppszBuf: LPPWSTR): HRESULT {
|
|
1348
|
+
return Propsys.Load('VariantToStringAlloc')(varIn, ppszBuf);
|
|
1349
|
+
}
|
|
1350
|
+
|
|
1351
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttostringarray
|
|
1352
|
+
public static VariantToStringArray(var_: REFVARIANT, prgsz: LPPWSTR, crgsz: ULONG, pcElem: LPULONG): HRESULT {
|
|
1353
|
+
return Propsys.Load('VariantToStringArray')(var_, prgsz, crgsz, pcElem);
|
|
1354
|
+
}
|
|
1355
|
+
|
|
1356
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttostringarrayalloc
|
|
1357
|
+
public static VariantToStringArrayAlloc(var_: REFVARIANT, pprgsz: LPLPPWSTR, pcElem: LPULONG): HRESULT {
|
|
1358
|
+
return Propsys.Load('VariantToStringArrayAlloc')(var_, pprgsz, pcElem);
|
|
1359
|
+
}
|
|
1360
|
+
|
|
1361
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttostringwithdefault
|
|
1362
|
+
public static VariantToStringWithDefault(varIn: REFVARIANT, pszDefault: LPCWSTR | NULL): PCWSTR {
|
|
1363
|
+
return Propsys.Load('VariantToStringWithDefault')(varIn, pszDefault);
|
|
1364
|
+
}
|
|
1365
|
+
|
|
1366
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint16
|
|
1367
|
+
public static VariantToUInt16(varIn: REFVARIANT, puiRet: LPUSHORT): HRESULT {
|
|
1368
|
+
return Propsys.Load('VariantToUInt16')(varIn, puiRet);
|
|
1369
|
+
}
|
|
1370
|
+
|
|
1371
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint16array
|
|
1372
|
+
public static VariantToUInt16Array(var_: REFVARIANT, prgn: LPUSHORT, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1373
|
+
return Propsys.Load('VariantToUInt16Array')(var_, prgn, crgn, pcElem);
|
|
1374
|
+
}
|
|
1375
|
+
|
|
1376
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint16arrayalloc
|
|
1377
|
+
public static VariantToUInt16ArrayAlloc(var_: REFVARIANT, pprgn: LPLPUSHORT, pcElem: LPULONG): HRESULT {
|
|
1378
|
+
return Propsys.Load('VariantToUInt16ArrayAlloc')(var_, pprgn, pcElem);
|
|
1379
|
+
}
|
|
1380
|
+
|
|
1381
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint16withdefault
|
|
1382
|
+
public static VariantToUInt16WithDefault(varIn: REFVARIANT, uiDefault: USHORT): USHORT {
|
|
1383
|
+
return Propsys.Load('VariantToUInt16WithDefault')(varIn, uiDefault);
|
|
1384
|
+
}
|
|
1385
|
+
|
|
1386
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint32
|
|
1387
|
+
public static VariantToUInt32(varIn: REFVARIANT, pulRet: LPULONG): HRESULT {
|
|
1388
|
+
return Propsys.Load('VariantToUInt32')(varIn, pulRet);
|
|
1389
|
+
}
|
|
1390
|
+
|
|
1391
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint32array
|
|
1392
|
+
public static VariantToUInt32Array(var_: REFVARIANT, prgn: LPULONG, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1393
|
+
return Propsys.Load('VariantToUInt32Array')(var_, prgn, crgn, pcElem);
|
|
1394
|
+
}
|
|
1395
|
+
|
|
1396
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint32arrayalloc
|
|
1397
|
+
public static VariantToUInt32ArrayAlloc(var_: REFVARIANT, pprgn: LPLPULONG, pcElem: LPULONG): HRESULT {
|
|
1398
|
+
return Propsys.Load('VariantToUInt32ArrayAlloc')(var_, pprgn, pcElem);
|
|
1399
|
+
}
|
|
1400
|
+
|
|
1401
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint32withdefault
|
|
1402
|
+
public static VariantToUInt32WithDefault(varIn: REFVARIANT, ulDefault: ULONG): ULONG {
|
|
1403
|
+
return Propsys.Load('VariantToUInt32WithDefault')(varIn, ulDefault);
|
|
1404
|
+
}
|
|
1405
|
+
|
|
1406
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint64
|
|
1407
|
+
public static VariantToUInt64(varIn: REFVARIANT, pullRet: LPULONGLONG): HRESULT {
|
|
1408
|
+
return Propsys.Load('VariantToUInt64')(varIn, pullRet);
|
|
1409
|
+
}
|
|
1410
|
+
|
|
1411
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint64array
|
|
1412
|
+
public static VariantToUInt64Array(var_: REFVARIANT, prgn: LPULONGLONG, crgn: ULONG, pcElem: LPULONG): HRESULT {
|
|
1413
|
+
return Propsys.Load('VariantToUInt64Array')(var_, prgn, crgn, pcElem);
|
|
1414
|
+
}
|
|
1415
|
+
|
|
1416
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint64arrayalloc
|
|
1417
|
+
public static VariantToUInt64ArrayAlloc(var_: REFVARIANT, pprgn: LPLPULONGLONG, pcElem: LPULONG): HRESULT {
|
|
1418
|
+
return Propsys.Load('VariantToUInt64ArrayAlloc')(var_, pprgn, pcElem);
|
|
1419
|
+
}
|
|
1420
|
+
|
|
1421
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propvarutil/nf-propvarutil-varianttouint64withdefault
|
|
1422
|
+
public static VariantToUInt64WithDefault(varIn: REFVARIANT, ullDefault: ULONGLONG): ULONGLONG {
|
|
1423
|
+
return Propsys.Load('VariantToUInt64WithDefault')(varIn, ullDefault);
|
|
1424
|
+
}
|
|
1425
|
+
|
|
1426
|
+
// https://learn.microsoft.com/en-us/windows/win32/api/propsys/nf-propsys-winrtpropertyvaluetopropvariant
|
|
1427
|
+
public static WinRTPropertyValueToPropVariant(punkPropertyValue: IUnknown | NULL, ppropvar: LPPROPVARIANT): HRESULT {
|
|
1428
|
+
return Propsys.Load('WinRTPropertyValueToPropVariant')(punkPropertyValue, ppropvar);
|
|
1429
|
+
}
|
|
1430
|
+
}
|
|
1431
|
+
|
|
1432
|
+
export default Propsys;
|