1unsafe extern "C" {
4 #[doc = " @brief\n This method will initialize the Sz processing object. It must be called\n once per process, prior to any other calls.\n\n @param moduleName A name for the processing node, to help identify it within\n system logs.\n @param iniParams A JSON string containing configuration parameters.\n @param initConfigID Identifier for the configuration to use in initialization.\n @param verboseLogging A flag to enable deeper logging of the Sz processing"]
5 pub fn Sz_init(
6 moduleName: *const libc::c_char,
7 iniParams: *const libc::c_char,
8 verboseLogging: i64,
9 ) -> i64;
10}
11unsafe extern "C" {
12 pub fn Sz_initWithConfigID(
13 moduleName: *const libc::c_char,
14 iniParams: *const libc::c_char,
15 initConfigID: i64,
16 verboseLogging: i64,
17 ) -> i64;
18}
19unsafe extern "C" {
20 #[doc = " @brief\n This method will re-initialize the Sz processing object."]
21 pub fn Sz_reinit(initConfigID: i64) -> i64;
22}
23unsafe extern "C" {
24 #[doc = " @brief\n This method will destroy and perform cleanup for the Sz processing object. It\n should be called after all other calls are complete."]
25 pub fn Sz_destroy() -> i64;
26}
27unsafe extern "C" {
28 #[doc = " @brief\n This method may optionally be called to pre-initialize some of the heavier weight\n internal resources of the Sz engine."]
29 pub fn Sz_primeEngine() -> i64;
30}
31unsafe extern "C" {
32 #[doc = " @brief Process a record contained in the internal redo-queue\n\n @param redoRecord Null terminated UT8-JSON record from Sz_getRedoRecord\n @param infoBuf Same as responseBuf. In a success, returns info about the\naffected entities\n @param infoBufSize Same as bufSize but for infoBuf\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer."]
33 pub fn Sz_processRedoRecord(redoRecord: *const libc::c_char) -> i64;
34}
35unsafe extern "C" {
36 pub fn Sz_processRedoRecordWithInfo(
37 redoRecord: *const libc::c_char,
38 infoBuf: *mut *mut libc::c_char,
39 infoBufSize: *mut usize,
40 resizeFunc: ::core::option::Option<
41 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
42 >,
43 ) -> i64;
44}
45unsafe extern "C" {
46 #[doc = " @brief Retrieve a record contained in the internal redo-queue\n\n @param responseBuf A memory buffer for returning the response document.\n If an error occurred, an error response is stored here.\n @param bufSize The max number of bytes that can be stored in responseBuf.\n The response buffer must be able to hold at least this many bytes,\n or a resize method must be provided that may be used to resize\n the buffer. This will return the new size.\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer."]
47 pub fn Sz_getRedoRecord(
48 responseBuf: *mut *mut libc::c_char,
49 bufSize: *mut usize,
50 resizeFunc: ::core::option::Option<
51 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
52 >,
53 ) -> i64;
54}
55unsafe extern "C" {
56 #[doc = " @brief Get the number of records contained in the internal redo-queue"]
57 pub fn Sz_countRedoRecords() -> i64;
58}
59unsafe extern "C" {
60 #[doc = " @brief\n This method returns a JSON document that provides basic statistics on\n the requests made through the Sz object. It returns things such as the\n number of records loaded, the duration of processing time, the number of\n retries made, etc.\n\n @param responseBuf A memory buffer for returning the response document.\n If an error occurred, an error response is stored here.\n @param bufSize The max number of bytes that can be stored in responseBuf.\n The response buffer must be able to hold at least this many bytes,\n or a resize method must be provided that may be used to resize\n the buffer. This will return the new size.\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer."]
61 pub fn Sz_stats(
62 responseBuf: *mut *mut libc::c_char,
63 bufSize: *mut usize,
64 resizeFunc: ::core::option::Option<
65 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
66 >,
67 ) -> i64;
68}
69unsafe extern "C" {
70 #[doc = " @brief\n This method returns an identifier for the loaded Sz engine configuration\n\n @param configID The identifier value for the config."]
71 pub fn Sz_getActiveConfigID(configID: *mut i64) -> i64;
72}
73unsafe extern "C" {
74 #[doc = " @brief\n This method is used to add entity data into the system. This adds or\n updates a single entity observation record, by adding features for the\n observation.\n\n @param dataSourceCode The data source for the observation.\n @param recordID The ID for the record\n @param jsonData A JSON document containing the attribute information\n for the observation.\n @param responseBuf A memory buffer for returning the response document.\n If an error occurred, an error response is stored here.\n @param bufSize The max number of bytes that can be stored in responseBuf.\n The response buffer must be able to hold at least this many bytes,\n or a resize method must be provided that may be used to resize\n the buffer. This will return the new size.\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer.\n @return Returns 0 for success. Returns -1 if the response status indicates\n failure or the module transport is not initialized. Returns -2 if\n an exception was thrown and caught."]
75 pub fn Sz_addRecord(
76 dataSourceCode: *const libc::c_char,
77 recordID: *const libc::c_char,
78 jsonData: *const libc::c_char,
79 ) -> i64;
80}
81unsafe extern "C" {
82 pub fn Sz_addRecordWithInfo(
83 dataSourceCode: *const libc::c_char,
84 recordID: *const libc::c_char,
85 jsonData: *const libc::c_char,
86 flags: i64,
87 responseBuf: *mut *mut libc::c_char,
88 bufSize: *mut usize,
89 resizeFunc: ::core::option::Option<
90 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
91 >,
92 ) -> i64;
93}
94unsafe extern "C" {
95 #[doc = " @brief Reevaluate an entity in the datastore."]
96 pub fn Sz_reevaluateRecord(
97 dataSourceCode: *const libc::c_char,
98 recordID: *const libc::c_char,
99 flags: i64,
100 ) -> i64;
101}
102unsafe extern "C" {
103 pub fn Sz_reevaluateEntity(entityID: i64, flags: i64) -> i64;
104}
105unsafe extern "C" {
106 pub fn Sz_reevaluateRecordWithInfo(
107 dataSourceCode: *const libc::c_char,
108 recordID: *const libc::c_char,
109 flags: i64,
110 responseBuf: *mut *mut libc::c_char,
111 bufSize: *mut usize,
112 resizeFunc: ::core::option::Option<
113 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
114 >,
115 ) -> i64;
116}
117unsafe extern "C" {
118 pub fn Sz_reevaluateEntityWithInfo(
119 entityID: i64,
120 flags: i64,
121 responseBuf: *mut *mut libc::c_char,
122 bufSize: *mut usize,
123 resizeFunc: ::core::option::Option<
124 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
125 >,
126 ) -> i64;
127}
128unsafe extern "C" {
129 #[doc = " @brief\n This method is used to delete observation data from the system. This\n removes a single entity observation record, by removing all of its\n feature data and the observation itself.\n\n @param dataSourceCode The data source for the observation.\n @param recordID The ID for the record\n @param responseBuf A buffer that returns a JSON object that summaries the changes cased by adding the\n record. Also contains the recordID.\n @param bufSize The size of the responseBuf buffer\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer.\n @return Returns 0 for success. Returns -1 if the response status indicates\n failure or the Sz module is not initialized. Returns -2 if\n an exception was thrown and caught."]
130 pub fn Sz_deleteRecord(
131 dataSourceCode: *const libc::c_char,
132 recordID: *const libc::c_char,
133 ) -> i64;
134}
135unsafe extern "C" {
136 pub fn Sz_deleteRecordWithInfo(
137 dataSourceCode: *const libc::c_char,
138 recordID: *const libc::c_char,
139 flags: i64,
140 responseBuf: *mut *mut libc::c_char,
141 bufSize: *mut usize,
142 resizeFunc: ::core::option::Option<
143 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
144 >,
145 ) -> i64;
146}
147unsafe extern "C" {
148 #[doc = " @brief\n This method gives a similar data response to getRecord but you supply\n the record instead of it being loaded.\n\n @param jsonData A JSON document containing the information to examine\n @param responseBuf A memory buffer for returning the response document.\n If an error occurred, an error response is stored here.\n @param bufSize The max number of bytes that can be stored in responseBuf.\n The response buffer must be able to hold at least this many bytes,\n or a resize method must be provided that may be used to resize\n the buffer. This will return the new size.\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer.\n @return Returns 0 for success. Returns -1 if the response status indicates\n failure or the Sz module is not initialized. Returns -2 if\n an exception was thrown and caught."]
149 pub fn Sz_getRecordPreview(
150 jsonData: *const libc::c_char,
151 flags: i64,
152 responseBuf: *mut *mut libc::c_char,
153 bufSize: *mut usize,
154 resizeFunc: ::core::option::Option<
155 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
156 >,
157 ) -> i64;
158}
159unsafe extern "C" {
160 #[doc = " @brief\n This method searches for entities that contain attribute information\n that are relevant to a set of input search attributes.\n\n @param jsonData A JSON document containing the attribute information\n to search for\n @param responseBuf A memory buffer for returning the response document.\n If an error occurred, an error response is stored here.\n @param bufSize The max number of bytes that can be stored in responseBuf.\n The response buffer must be able to hold at least this many bytes,\n or a resize method must be provided that may be used to resize\n the buffer. This will return the new size.\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer.\n @return Returns 0 for success. Returns -1 if the response status indicates\n failure or the Sz module is not initialized. Returns -2 if\n an exception was thrown and caught."]
161 pub fn Sz_searchByAttributes(
162 jsonData: *const libc::c_char,
163 responseBuf: *mut *mut libc::c_char,
164 bufSize: *mut usize,
165 resizeFunc: ::core::option::Option<
166 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
167 >,
168 ) -> i64;
169}
170unsafe extern "C" {
171 pub fn Sz_searchByAttributes_V2(
172 jsonData: *const libc::c_char,
173 flags: i64,
174 responseBuf: *mut *mut libc::c_char,
175 bufSize: *mut usize,
176 resizeFunc: ::core::option::Option<
177 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
178 >,
179 ) -> i64;
180}
181unsafe extern "C" {
182 pub fn Sz_searchByAttributes_V3(
183 jsonData: *const libc::c_char,
184 searchProfile: *const libc::c_char,
185 flags: i64,
186 responseBuf: *mut *mut libc::c_char,
187 bufSize: *mut usize,
188 resizeFunc: ::core::option::Option<
189 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
190 >,
191 ) -> i64;
192}
193unsafe extern "C" {
194 #[doc = " @brief\n This method is used to retrieve information about a specific resolved\n entity. The information is returned as a JSON document.\n\n @param entityID The resolved entity to retrieve information for\n @param dataSourceCode The data source of the observation to search for\n @param recordID The record ID of the observation to search for\n @param responseBuf A memory buffer for returning the response document.\n If an error occurred, an error response is stored here.\n @param bufSize The max number of bytes that can be stored in responseBuf.\n The response buffer must be able to hold at least this many bytes,\n or a resize method must be provided that may be used to resize\n the buffer. This will return the new size.\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer.\n @return Returns 0 for success. Returns -1 if the response status indicates\n failure or the Sz module is not initialized. Returns -2 if\n an exception was thrown and caught."]
195 pub fn Sz_getEntityByEntityID(
196 entityID: i64,
197 responseBuf: *mut *mut libc::c_char,
198 bufSize: *mut usize,
199 resizeFunc: ::core::option::Option<
200 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
201 >,
202 ) -> i64;
203}
204unsafe extern "C" {
205 pub fn Sz_getEntityByEntityID_V2(
206 entityID: i64,
207 flags: i64,
208 responseBuf: *mut *mut libc::c_char,
209 bufSize: *mut usize,
210 resizeFunc: ::core::option::Option<
211 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
212 >,
213 ) -> i64;
214}
215unsafe extern "C" {
216 pub fn Sz_getEntityByRecordID(
217 dataSourceCode: *const libc::c_char,
218 recordID: *const libc::c_char,
219 responseBuf: *mut *mut libc::c_char,
220 bufSize: *mut usize,
221 resizeFunc: ::core::option::Option<
222 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
223 >,
224 ) -> i64;
225}
226unsafe extern "C" {
227 pub fn Sz_getEntityByRecordID_V2(
228 dataSourceCode: *const libc::c_char,
229 recordID: *const libc::c_char,
230 flags: i64,
231 responseBuf: *mut *mut libc::c_char,
232 bufSize: *mut usize,
233 resizeFunc: ::core::option::Option<
234 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
235 >,
236 ) -> i64;
237}
238unsafe extern "C" {
239 #[doc = " @brief\n This method is used to retrieve a stored record.\n\n @param dataSourceCode The data source of the observation to search for\n @param recordID The record ID of the observation to search for\n @param responseBuf A memory buffer for returning the response document.\n If an error occurred, an error response is stored here.\n @param bufSize The max number of bytes that can be stored in responseBuf.\n The response buffer must be able to hold at least this many bytes,\n or a resize method must be provided that may be used to resize\n the buffer. This will return the new size.\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer.\n @return Returns 0 for success. Returns -1 if the response status indicates\n failure or the Sz module is not initialized. Returns -2 if\n an exception was thrown and caught."]
240 pub fn Sz_getRecord(
241 dataSourceCode: *const libc::c_char,
242 recordID: *const libc::c_char,
243 responseBuf: *mut *mut libc::c_char,
244 bufSize: *mut usize,
245 resizeFunc: ::core::option::Option<
246 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
247 >,
248 ) -> i64;
249}
250unsafe extern "C" {
251 pub fn Sz_getRecord_V2(
252 dataSourceCode: *const libc::c_char,
253 recordID: *const libc::c_char,
254 flags: i64,
255 responseBuf: *mut *mut libc::c_char,
256 bufSize: *mut usize,
257 resizeFunc: ::core::option::Option<
258 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
259 >,
260 ) -> i64;
261}
262unsafe extern "C" {
263 #[doc = " @brief\n This method is used to find a relationship path between entities.\n\n @param entityID1 The starting entity of the relationship path\n @param entityID2 The ending entity of the relationship path\n @param dataSourceCode1 The data source for the starting record of the relationship path\n @param recordID1 The record ID for the starting record of the relationship path\n @param dataSourceCode2 The data source for the ending record of the relationship path\n @param recordID2 The record ID for the ending record of the relationship path\n @param maxDegree The maximum degree of relationships to search\n @param responseBuf A memory buffer for returning the response document.\n @param bufSize The max number of bytes that can be stored in responseBuf.\n The response buffer must be able to hold the whole response message,\n or a resize method must be provided that may be used to resize\n the buffer. This will return the new size.\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer.\n @return Returns 0 for success. Returns -1 if the response status indicates\n failure or the Sz module is not initialized. Returns -2 if\n an exception was thrown and caught."]
264 pub fn Sz_findPathByEntityID(
265 entityID1: i64,
266 entityID2: i64,
267 maxDegree: i64,
268 responseBuf: *mut *mut libc::c_char,
269 bufSize: *mut usize,
270 resizeFunc: ::core::option::Option<
271 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
272 >,
273 ) -> i64;
274}
275unsafe extern "C" {
276 pub fn Sz_findPathByEntityID_V2(
277 entityID1: i64,
278 entityID2: i64,
279 maxDegree: i64,
280 flags: i64,
281 responseBuf: *mut *mut libc::c_char,
282 bufSize: *mut usize,
283 resizeFunc: ::core::option::Option<
284 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
285 >,
286 ) -> i64;
287}
288unsafe extern "C" {
289 pub fn Sz_findPathByRecordID(
290 dataSourceCode1: *const libc::c_char,
291 recordID1: *const libc::c_char,
292 dataSourceCode2: *const libc::c_char,
293 recordID2: *const libc::c_char,
294 maxDegree: i64,
295 responseBuf: *mut *mut libc::c_char,
296 bufSize: *mut usize,
297 resizeFunc: ::core::option::Option<
298 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
299 >,
300 ) -> i64;
301}
302unsafe extern "C" {
303 pub fn Sz_findPathByRecordID_V2(
304 dataSourceCode1: *const libc::c_char,
305 recordID1: *const libc::c_char,
306 dataSourceCode2: *const libc::c_char,
307 recordID2: *const libc::c_char,
308 maxDegree: i64,
309 flags: i64,
310 responseBuf: *mut *mut libc::c_char,
311 bufSize: *mut usize,
312 resizeFunc: ::core::option::Option<
313 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
314 >,
315 ) -> i64;
316}
317unsafe extern "C" {
318 #[doc = " @brief\n This method is used to find a relationship path between entities, that avoids\n a particular set of entities.\n\n @param entityID1 The starting entity of the relationship path\n @param entityID2 The ending entity of the relationship path\n @param dataSourceCode1 The data source for the starting record of the relationship path\n @param recordID1 The record ID for the starting record of the relationship path\n @param dataSourceCode2 The data source for the ending record of the relationship path\n @param recordID2 The record ID for the ending record of the relationship path\n @param maxDegree The maximum degree of relationships to search\n @param avoidedEntities A JSON document identifying the list of entities to\n avoid in the path.\n (example: {\"ENTITIES\":[{\"ENTITY_ID\":\"6\"},{\"ENTITY_ID\":\"11\"},{\"ENTITY_ID\":\"9\"}]} )\n @param avoidedRecords A JSON document identifying the list of records for\n entities to avoid in the path.\n (example:\n {\"RECORDS\":[{\"DATA_SOURCE\":\"PEOPLE\",\"RECORD_ID\":\"1504\"},{\"DATA_SOURCE\":\"PEOPLE\",\"RECORD_ID\":\"1507\"}]} )\n @param flags A bit mask specifying control flags, such as\n \"SZ_FIND_PATH_STRICT_AVOID\". The default and recommended\n value is \"SZ_FIND_PATH_DEFAULT_FLAGS\".\n @param responseBuf A memory buffer for returning the response document.\n @param bufSize The max number of bytes that can be stored in responseBuf.\n The response buffer must be able to hold the whole response message,\n or a resize method must be provided that may be used to resize\n the buffer. This will return the new size.\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer.\n @return Returns 0 for success. Returns -1 if the response status indicates\n failure or the Sz module is not initialized. Returns -2 if\n an exception was thrown and caught."]
319 pub fn Sz_findPathByEntityIDWithAvoids(
320 entityID1: i64,
321 entityID2: i64,
322 maxDegree: i64,
323 avoidedEntities: *const libc::c_char,
324 responseBuf: *mut *mut libc::c_char,
325 bufSize: *mut usize,
326 resizeFunc: ::core::option::Option<
327 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
328 >,
329 ) -> i64;
330}
331unsafe extern "C" {
332 pub fn Sz_findPathByEntityIDWithAvoids_V2(
333 entityID1: i64,
334 entityID2: i64,
335 maxDegree: i64,
336 avoidedEntities: *const libc::c_char,
337 flags: i64,
338 responseBuf: *mut *mut libc::c_char,
339 bufSize: *mut usize,
340 resizeFunc: ::core::option::Option<
341 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
342 >,
343 ) -> i64;
344}
345unsafe extern "C" {
346 pub fn Sz_findPathByRecordIDWithAvoids(
347 dataSourceCode1: *const libc::c_char,
348 recordID1: *const libc::c_char,
349 dataSourceCode2: *const libc::c_char,
350 recordID2: *const libc::c_char,
351 maxDegree: i64,
352 avoidedRecords: *const libc::c_char,
353 responseBuf: *mut *mut libc::c_char,
354 bufSize: *mut usize,
355 resizeFunc: ::core::option::Option<
356 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
357 >,
358 ) -> i64;
359}
360unsafe extern "C" {
361 pub fn Sz_findPathByRecordIDWithAvoids_V2(
362 dataSourceCode1: *const libc::c_char,
363 recordID1: *const libc::c_char,
364 dataSourceCode2: *const libc::c_char,
365 recordID2: *const libc::c_char,
366 maxDegree: i64,
367 avoidedRecords: *const libc::c_char,
368 flags: i64,
369 responseBuf: *mut *mut libc::c_char,
370 bufSize: *mut usize,
371 resizeFunc: ::core::option::Option<
372 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
373 >,
374 ) -> i64;
375}
376unsafe extern "C" {
377 #[doc = " @brief\n This method is used to find a relationship path between entities, that avoids\n a particular set of entities, and also requires at least one data source from a\n set to be part of the path.\n\n @param entityID1 The starting entity of the relationship path\n @param entityID2 The ending entity of the relationship path\n @param dataSourceCode1 The data source for the starting record of the relationship path\n @param recordID1 The record ID for the starting record of the relationship path\n @param dataSourceCode2 The data source for the ending record of the relationship path\n @param recordID2 The record ID for the ending record of the relationship path\n @param maxDegree The maximum degree of relationships to search\n @param avoidedEntities A JSON document identifying the list of entities to\n avoid in the path.\n (example: {\"ENTITIES\":[{\"ENTITY_ID\":\"6\"},{\"ENTITY_ID\":\"11\"},{\"ENTITY_ID\":\"9\"}]} )\n @param avoidedRecords A JSON document identifying the list of records for\n entities to avoid in the path.\n (example:\n {\"RECORDS\":[{\"DATA_SOURCE\":\"PEOPLE\",\"RECORD_ID\":\"1504\"},{\"DATA_SOURCE\":\"PEOPLE\",\"RECORD_ID\":\"1507\"}]} )\n @param requiredDsrcs A JSON document identifying the list of data sources to watch for\n (example: {\"DATA_SOURCES\":[\"PEOPLE\",\"COMPANIES\"]} )\n @param flags A bit mask specifying control flags, such as\n \"SZ_FIND_PATH_STRICT_AVOID\". The default and recommended\n value is \"SZ_FIND_PATH_DEFAULT_FLAGS\".\n @param responseBuf A memory buffer for returning the response document.\n @param bufSize The max number of bytes that can be stored in responseBuf.\n The response buffer must be able to hold the whole response message,\n or a resize method must be provided that may be used to resize\n the buffer. This will return the new size.\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer.\n @return Returns 0 for success. Returns -1 if the response status indicates\n failure or the Sz module is not initialized. Returns -2 if\n an exception was thrown and caught."]
378 pub fn Sz_findPathByEntityIDIncludingSource(
379 entityID1: i64,
380 entityID2: i64,
381 maxDegree: i64,
382 avoidedEntities: *const libc::c_char,
383 requiredDsrcs: *const libc::c_char,
384 responseBuf: *mut *mut libc::c_char,
385 bufSize: *mut usize,
386 resizeFunc: ::core::option::Option<
387 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
388 >,
389 ) -> i64;
390}
391unsafe extern "C" {
392 pub fn Sz_findPathByEntityIDIncludingSource_V2(
393 entityID1: i64,
394 entityID2: i64,
395 maxDegree: i64,
396 avoidedEntities: *const libc::c_char,
397 requiredDsrcs: *const libc::c_char,
398 flags: i64,
399 responseBuf: *mut *mut libc::c_char,
400 bufSize: *mut usize,
401 resizeFunc: ::core::option::Option<
402 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
403 >,
404 ) -> i64;
405}
406unsafe extern "C" {
407 pub fn Sz_findPathByRecordIDIncludingSource(
408 dataSourceCode1: *const libc::c_char,
409 recordID1: *const libc::c_char,
410 dataSourceCode2: *const libc::c_char,
411 recordID2: *const libc::c_char,
412 maxDegree: i64,
413 avoidedRecords: *const libc::c_char,
414 requiredDsrcs: *const libc::c_char,
415 responseBuf: *mut *mut libc::c_char,
416 bufSize: *mut usize,
417 resizeFunc: ::core::option::Option<
418 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
419 >,
420 ) -> i64;
421}
422unsafe extern "C" {
423 pub fn Sz_findPathByRecordIDIncludingSource_V2(
424 dataSourceCode1: *const libc::c_char,
425 recordID1: *const libc::c_char,
426 dataSourceCode2: *const libc::c_char,
427 recordID2: *const libc::c_char,
428 maxDegree: i64,
429 avoidedRecords: *const libc::c_char,
430 requiredDsrcs: *const libc::c_char,
431 flags: i64,
432 responseBuf: *mut *mut libc::c_char,
433 bufSize: *mut usize,
434 resizeFunc: ::core::option::Option<
435 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
436 >,
437 ) -> i64;
438}
439unsafe extern "C" {
440 #[doc = " @brief\n This method is used to find a network of entity relationships, surrounding the paths between\n a set of entities.\n\n @param entityList A JSON document identifying the list of entities to\n find paths between and a network around.\n (example: {\"ENTITIES\":[{\"ENTITY_ID\":\"6\"},{\"ENTITY_ID\":\"11\"},{\"ENTITY_ID\":\"9\"}]} )\n @param recordList A JSON document identifying the list of record entities to\n find paths between and a network around.\n (example:\n {\"RECORDS\":[{\"DATA_SOURCE\":\"PEOPLE\",\"RECORD_ID\":\"1504\"},{\"DATA_SOURCE\":\"PEOPLE\",\"RECORD_ID\":\"1507\"},{\"DATA_SOURCE\":\"PEOPLE\",\"RECORD_ID\":\"1510\"}]}\n )\n @param maxDegree The maximum degree of relationships to search for a path\n @param buildOutDegree The maximum degree of relationships to include in the network\n around each entity\n @param maxEntities The maximum number of entities to return\n @param responseBuf A memory buffer for returning the response document.\n @param bufSize The max number of bytes that can be stored in responseBuf.\n The response buffer must be able to hold the whole response message,\n or a resize method must be provided that may be used to resize\n the buffer. This will return the new size.\n @param resizeFunc A function pointer that can be used to resize the memory\n buffer specified in the responseBuf argument. This function will\n be called to allocate more memory if the response buffer is not large\n enough. This argument may be NULL. If it is NULL, the function\n will return an error if the result is larger than the buffer.\n @return Returns 0 for success. Returns -1 if the response status indicates\n failure or the Sz module is not initialized. Returns -2 if\n an exception was thrown and caught."]
441 pub fn Sz_findNetworkByEntityID(
442 entityList: *const libc::c_char,
443 maxDegree: i64,
444 buildOutDegree: i64,
445 maxEntities: i64,
446 responseBuf: *mut *mut libc::c_char,
447 bufSize: *mut usize,
448 resizeFunc: ::core::option::Option<
449 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
450 >,
451 ) -> i64;
452}
453unsafe extern "C" {
454 pub fn Sz_findNetworkByEntityID_V2(
455 entityList: *const libc::c_char,
456 maxDegree: i64,
457 buildOutDegree: i64,
458 maxEntities: i64,
459 flags: i64,
460 responseBuf: *mut *mut libc::c_char,
461 bufSize: *mut usize,
462 resizeFunc: ::core::option::Option<
463 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
464 >,
465 ) -> i64;
466}
467unsafe extern "C" {
468 pub fn Sz_findNetworkByRecordID(
469 recordList: *const libc::c_char,
470 maxDegree: i64,
471 buildOutDegree: i64,
472 maxEntities: i64,
473 responseBuf: *mut *mut libc::c_char,
474 bufSize: *mut usize,
475 resizeFunc: ::core::option::Option<
476 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
477 >,
478 ) -> i64;
479}
480unsafe extern "C" {
481 pub fn Sz_findNetworkByRecordID_V2(
482 recordList: *const libc::c_char,
483 maxDegree: i64,
484 buildOutDegree: i64,
485 maxEntities: i64,
486 flags: i64,
487 responseBuf: *mut *mut libc::c_char,
488 bufSize: *mut usize,
489 resizeFunc: ::core::option::Option<
490 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
491 >,
492 ) -> i64;
493}
494unsafe extern "C" {
495 #[doc = " @brief\n This method determines what interesting entities exist around a particular resolved entity"]
496 pub fn Sz_findInterestingEntitiesByEntityID(
497 entityID: i64,
498 flags: i64,
499 responseBuf: *mut *mut libc::c_char,
500 bufSize: *mut usize,
501 resizeFunc: ::core::option::Option<
502 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
503 >,
504 ) -> i64;
505}
506unsafe extern "C" {
507 pub fn Sz_findInterestingEntitiesByRecordID(
508 dataSourceCode: *const libc::c_char,
509 recordID: *const libc::c_char,
510 flags: i64,
511 responseBuf: *mut *mut libc::c_char,
512 bufSize: *mut usize,
513 resizeFunc: ::core::option::Option<
514 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
515 >,
516 ) -> i64;
517}
518unsafe extern "C" {
519 #[doc = " @brief\n This method determines why a particular record is included in its resolved entity."]
520 pub fn Sz_whyRecordInEntity(
521 dataSourceCode: *const libc::c_char,
522 recordID: *const libc::c_char,
523 responseBuf: *mut *mut libc::c_char,
524 bufSize: *mut usize,
525 resizeFunc: ::core::option::Option<
526 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
527 >,
528 ) -> i64;
529}
530unsafe extern "C" {
531 pub fn Sz_whyRecordInEntity_V2(
532 dataSourceCode: *const libc::c_char,
533 recordID: *const libc::c_char,
534 flags: i64,
535 responseBuf: *mut *mut libc::c_char,
536 bufSize: *mut usize,
537 resizeFunc: ::core::option::Option<
538 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
539 >,
540 ) -> i64;
541}
542unsafe extern "C" {
543 #[doc = " @brief\n This method determines how records are related to each other."]
544 pub fn Sz_whyRecords(
545 dataSourceCode1: *const libc::c_char,
546 recordID1: *const libc::c_char,
547 dataSourceCode2: *const libc::c_char,
548 recordID2: *const libc::c_char,
549 responseBuf: *mut *mut libc::c_char,
550 bufSize: *mut usize,
551 resizeFunc: ::core::option::Option<
552 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
553 >,
554 ) -> i64;
555}
556unsafe extern "C" {
557 pub fn Sz_whyRecords_V2(
558 dataSourceCode1: *const libc::c_char,
559 recordID1: *const libc::c_char,
560 dataSourceCode2: *const libc::c_char,
561 recordID2: *const libc::c_char,
562 flags: i64,
563 responseBuf: *mut *mut libc::c_char,
564 bufSize: *mut usize,
565 resizeFunc: ::core::option::Option<
566 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
567 >,
568 ) -> i64;
569}
570unsafe extern "C" {
571 #[doc = " @brief\n This method determines how entities are related to each other."]
572 pub fn Sz_whyEntities(
573 entityID1: i64,
574 entityID2: i64,
575 responseBuf: *mut *mut libc::c_char,
576 bufSize: *mut usize,
577 resizeFunc: ::core::option::Option<
578 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
579 >,
580 ) -> i64;
581}
582unsafe extern "C" {
583 pub fn Sz_whyEntities_V2(
584 entityID1: i64,
585 entityID2: i64,
586 flags: i64,
587 responseBuf: *mut *mut libc::c_char,
588 bufSize: *mut usize,
589 resizeFunc: ::core::option::Option<
590 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
591 >,
592 ) -> i64;
593}
594unsafe extern "C" {
595 #[doc = " @brief\n This method determines how a search record relates to an existing entity."]
596 pub fn Sz_whySearch(
597 jsonData: *const libc::c_char,
598 entityID: i64,
599 searchProfile: *const libc::c_char,
600 responseBuf: *mut *mut libc::c_char,
601 bufSize: *mut usize,
602 resizeFunc: ::core::option::Option<
603 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
604 >,
605 ) -> i64;
606}
607unsafe extern "C" {
608 pub fn Sz_whySearch_V2(
609 jsonData: *const libc::c_char,
610 entityID: i64,
611 searchProfile: *const libc::c_char,
612 flags: i64,
613 responseBuf: *mut *mut libc::c_char,
614 bufSize: *mut usize,
615 resizeFunc: ::core::option::Option<
616 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
617 >,
618 ) -> i64;
619}
620unsafe extern "C" {
621 #[doc = " @brief\n This method gives information on how entities were constructed from their base records."]
622 pub fn Sz_howEntityByEntityID(
623 entityID: i64,
624 responseBuf: *mut *mut libc::c_char,
625 bufSize: *mut usize,
626 resizeFunc: ::core::option::Option<
627 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
628 >,
629 ) -> i64;
630}
631unsafe extern "C" {
632 pub fn Sz_howEntityByEntityID_V2(
633 entityID: i64,
634 flags: i64,
635 responseBuf: *mut *mut libc::c_char,
636 bufSize: *mut usize,
637 resizeFunc: ::core::option::Option<
638 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
639 >,
640 ) -> i64;
641}
642unsafe extern "C" {
643 #[doc = " @brief\n This method gives information on how an entity composed of a given set of records would look"]
644 pub fn Sz_getVirtualEntityByRecordID(
645 recordList: *const libc::c_char,
646 responseBuf: *mut *mut libc::c_char,
647 bufSize: *mut usize,
648 resizeFunc: ::core::option::Option<
649 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
650 >,
651 ) -> i64;
652}
653unsafe extern "C" {
654 pub fn Sz_getVirtualEntityByRecordID_V2(
655 recordList: *const libc::c_char,
656 flags: i64,
657 responseBuf: *mut *mut libc::c_char,
658 bufSize: *mut usize,
659 resizeFunc: ::core::option::Option<
660 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
661 >,
662 ) -> i64;
663}
664pub type ExportHandle = usize;
665unsafe extern "C" {
666 #[doc = " @brief\n This is used to export entity data from known entities. This function\n returns an export-handle that can be read from to get the export data\n in JSON format. The export-handle should be read using the \"Sz_fetchNext\"\n function, and closed when work is complete. Each output row contains the\n exported entity data for a single resolved entity.\n\n @param flags A bit mask specifying control flags, such as\n \"SZ_EXPORT_INCLUDE_SINGLE_RECORD_ENTITIES\". The default and recommended\n value is \"SZ_EXPORT_DEFAULT_FLAGS\".\n\n @return Returns an export handle that the entity data can be read from."]
667 pub fn Sz_exportJSONEntityReport(flags: i64, responseHandle: *mut ExportHandle) -> i64;
668}
669unsafe extern "C" {
670 #[doc = " @brief\n This is used to export entity data from known entities. This function\n returns an export-handle that can be read from to get the export data\n in CSV format. The export-handle should be read using the \"Sz_fetchNext\"\n function, and closed when work is complete. The first output row returned\n by the export-handle contains the JSON column headers as a string. Each\n following row contains the exported entity data.\n\n @param flags A bit mask specifying other control flags, such as\n \"SZ_EXPORT_INCLUDE_SINGLE_RECORD_ENTITIES\". The default and recommended\n value is \"SZ_EXPORT_DEFAULT_FLAGS\".\n\n @return Returns an export handle that the entity data can be read from."]
671 pub fn Sz_exportCSVEntityReport(
672 csvColumnList: *const libc::c_char,
673 flags: i64,
674 responseHandle: *mut ExportHandle,
675 ) -> i64;
676}
677unsafe extern "C" {
678 #[doc = " @brief\n This function is used to read entity data from an export handle,\n one data row at a time.\n\n @param responseHandle The export handle to retrieve data from\n @param responseBuf The buffer to write the string data to\n @param bufSize The size of the response buffer\n\n @return Returns a pointer to the buffer if successful, or -1 otherwise"]
679 pub fn Sz_fetchNext(
680 responseHandle: ExportHandle,
681 responseBuf: *mut libc::c_char,
682 bufSize: usize,
683 ) -> i64;
684}
685unsafe extern "C" {
686 #[doc = " @brief\n This function closes an export handle, to clean up system resources."]
687 pub fn Sz_closeExportReport(responseHandle: ExportHandle) -> i64;
688}
689unsafe extern "C" {
690 #[doc = " @brief\n This function retrieves the last exception thrown in the engine\n @return number of bytes copied into buffer"]
691 pub fn Sz_getLastException(buffer: *mut libc::c_char, bufSize: usize) -> i64;
692}
693unsafe extern "C" {
694 #[doc = " @brief\n This function retrieves the code of the last exception thrown in the engine\n @return number of bytes copied into buffer"]
695 pub fn Sz_getLastExceptionCode() -> i64;
696}
697unsafe extern "C" {
698 #[doc = " @brief\n This function clears the last exception thrown in libSz"]
699 pub fn Sz_clearLastException();
700}
701unsafe extern "C" {
702 pub fn SzHelper_free(p: *mut libc::c_void);
703}
704#[repr(C)]
705#[derive(Debug, Copy, Clone)]
706pub struct SzConfig_registerDataSource_result {
707 pub response: *mut libc::c_char,
708 pub returnCode: i64,
709}
710impl Default for SzConfig_registerDataSource_result {
711 fn default() -> Self {
712 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
713 unsafe {
714 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
715 s.assume_init()
716 }
717 }
718}
719#[repr(C)]
720#[derive(Debug, Default, Copy, Clone)]
721pub struct SzConfig_create_result {
722 pub response: usize,
723 pub returnCode: i64,
724}
725#[repr(C)]
726#[derive(Debug, Copy, Clone)]
727pub struct SzConfig_getDataSourceRegistry_result {
728 pub response: *mut libc::c_char,
729 pub returnCode: i64,
730}
731impl Default for SzConfig_getDataSourceRegistry_result {
732 fn default() -> Self {
733 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
734 unsafe {
735 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
736 s.assume_init()
737 }
738 }
739}
740#[repr(C)]
741#[derive(Debug, Copy, Clone)]
742pub struct SzConfig_load_result {
743 pub response: *mut libc::c_void,
744 pub returnCode: i64,
745}
746impl Default for SzConfig_load_result {
747 fn default() -> Self {
748 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
749 unsafe {
750 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
751 s.assume_init()
752 }
753 }
754}
755#[repr(C)]
756#[derive(Debug, Copy, Clone)]
757pub struct SzConfig_export_result {
758 pub response: *mut libc::c_char,
759 pub returnCode: i64,
760}
761impl Default for SzConfig_export_result {
762 fn default() -> Self {
763 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
764 unsafe {
765 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
766 s.assume_init()
767 }
768 }
769}
770unsafe extern "C" {
771 pub fn SzConfig_registerDataSource_helper(
772 configHandle: usize,
773 inputJson: *const libc::c_char,
774 ) -> SzConfig_registerDataSource_result;
775}
776unsafe extern "C" {
777 pub fn SzConfig_close_helper(configHandle: usize) -> i64;
778}
779unsafe extern "C" {
780 pub fn SzConfig_create_helper() -> SzConfig_create_result;
781}
782unsafe extern "C" {
783 pub fn SzConfig_unregisterDataSource_helper(
784 configHandle: usize,
785 inputJson: *const libc::c_char,
786 ) -> i64;
787}
788unsafe extern "C" {
789 pub fn SzConfig_getDataSourceRegistry_helper(
790 configHandle: usize,
791 ) -> SzConfig_getDataSourceRegistry_result;
792}
793unsafe extern "C" {
794 pub fn SzConfig_load_helper(inputJson: *const libc::c_char) -> SzConfig_load_result;
795}
796unsafe extern "C" {
797 pub fn SzConfig_export_helper(configHandle: usize) -> SzConfig_export_result;
798}
799#[repr(C)]
800#[derive(Debug, Default, Copy, Clone)]
801pub struct SzConfigMgr_registerConfig_result {
802 pub configID: i64,
803 pub returnCode: i64,
804}
805#[repr(C)]
806#[derive(Debug, Copy, Clone)]
807pub struct SzConfigMgr_getConfig_result {
808 pub response: *mut libc::c_char,
809 pub returnCode: i64,
810}
811impl Default for SzConfigMgr_getConfig_result {
812 fn default() -> Self {
813 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
814 unsafe {
815 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
816 s.assume_init()
817 }
818 }
819}
820#[repr(C)]
821#[derive(Debug, Copy, Clone)]
822pub struct SzConfigMgr_getConfigRegistry_result {
823 pub response: *mut libc::c_char,
824 pub returnCode: i64,
825}
826impl Default for SzConfigMgr_getConfigRegistry_result {
827 fn default() -> Self {
828 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
829 unsafe {
830 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
831 s.assume_init()
832 }
833 }
834}
835#[repr(C)]
836#[derive(Debug, Default, Copy, Clone)]
837pub struct SzConfigMgr_getDefaultConfigID_result {
838 pub configID: i64,
839 pub returnCode: i64,
840}
841unsafe extern "C" {
842 pub fn SzConfigMgr_registerConfig_helper(
843 configStr: *const libc::c_char,
844 configComments: *const libc::c_char,
845 ) -> SzConfigMgr_registerConfig_result;
846}
847unsafe extern "C" {
848 pub fn SzConfigMgr_getConfig_helper(configID: i64) -> SzConfigMgr_getConfig_result;
849}
850unsafe extern "C" {
851 pub fn SzConfigMgr_getConfigRegistry_helper() -> SzConfigMgr_getConfigRegistry_result;
852}
853unsafe extern "C" {
854 pub fn SzConfigMgr_getDefaultConfigID_helper() -> SzConfigMgr_getDefaultConfigID_result;
855}
856#[repr(C)]
857#[derive(Debug, Copy, Clone)]
858pub struct SzDiagnostic_checkRepositoryPerformance_result {
859 pub response: *mut libc::c_char,
860 pub returnCode: i64,
861}
862impl Default for SzDiagnostic_checkRepositoryPerformance_result {
863 fn default() -> Self {
864 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
865 unsafe {
866 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
867 s.assume_init()
868 }
869 }
870}
871unsafe extern "C" {
872 pub fn SzDiagnostic_checkRepositoryPerformance_helper(
873 secondsToRun: i64,
874 ) -> SzDiagnostic_checkRepositoryPerformance_result;
875}
876#[repr(C)]
877#[derive(Debug, Copy, Clone)]
878pub struct SzDiagnostic_getRepositoryInfo_result {
879 pub response: *mut libc::c_char,
880 pub returnCode: i64,
881}
882impl Default for SzDiagnostic_getRepositoryInfo_result {
883 fn default() -> Self {
884 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
885 unsafe {
886 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
887 s.assume_init()
888 }
889 }
890}
891unsafe extern "C" {
892 pub fn SzDiagnostic_getRepositoryInfo_helper() -> SzDiagnostic_getRepositoryInfo_result;
893}
894#[repr(C)]
895#[derive(Debug, Copy, Clone)]
896pub struct SzDiagnostic_getFeature_result {
897 pub response: *mut libc::c_char,
898 pub returnCode: i64,
899}
900impl Default for SzDiagnostic_getFeature_result {
901 fn default() -> Self {
902 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
903 unsafe {
904 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
905 s.assume_init()
906 }
907 }
908}
909unsafe extern "C" {
910 #[doc = " THIS FUNCTION IS UNSUPPORTED AND UNDOCUMENTED. ANY USE IS WITHOUT WARRANTY OF ANY KIND."]
911 pub fn SzDiagnostic_getFeature_helper(libFeatId: i64) -> SzDiagnostic_getFeature_result;
912}
913#[repr(C)]
914#[derive(Debug, Copy, Clone)]
915pub struct Sz_addRecordWithInfo_result {
916 pub response: *mut libc::c_char,
917 pub returnCode: i64,
918}
919impl Default for Sz_addRecordWithInfo_result {
920 fn default() -> Self {
921 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
922 unsafe {
923 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
924 s.assume_init()
925 }
926 }
927}
928#[repr(C)]
929#[derive(Debug, Copy, Clone)]
930pub struct Sz_processRedoRecordWithInfo_result {
931 pub response: *mut libc::c_char,
932 pub returnCode: i64,
933}
934impl Default for Sz_processRedoRecordWithInfo_result {
935 fn default() -> Self {
936 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
937 unsafe {
938 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
939 s.assume_init()
940 }
941 }
942}
943#[repr(C)]
944#[derive(Debug, Copy, Clone)]
945pub struct Sz_deleteRecordWithInfo_result {
946 pub response: *mut libc::c_char,
947 pub returnCode: i64,
948}
949impl Default for Sz_deleteRecordWithInfo_result {
950 fn default() -> Self {
951 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
952 unsafe {
953 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
954 s.assume_init()
955 }
956 }
957}
958#[repr(C)]
959#[derive(Debug, Default, Copy, Clone)]
960pub struct Sz_exportCSVEntityReport_result {
961 pub exportHandle: usize,
962 pub returnCode: i64,
963}
964#[repr(C)]
965#[derive(Debug, Default, Copy, Clone)]
966pub struct Sz_exportJSONEntityReport_result {
967 pub exportHandle: usize,
968 pub returnCode: i64,
969}
970#[repr(C)]
971#[derive(Debug, Copy, Clone)]
972pub struct Sz_fetchNext_result {
973 pub response: *mut libc::c_char,
974 pub returnCode: i64,
975}
976impl Default for Sz_fetchNext_result {
977 fn default() -> Self {
978 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
979 unsafe {
980 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
981 s.assume_init()
982 }
983 }
984}
985#[repr(C)]
986#[derive(Debug, Copy, Clone)]
987pub struct Sz_findInterestingEntitiesByEntityID_result {
988 pub response: *mut libc::c_char,
989 pub returnCode: i64,
990}
991impl Default for Sz_findInterestingEntitiesByEntityID_result {
992 fn default() -> Self {
993 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
994 unsafe {
995 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
996 s.assume_init()
997 }
998 }
999}
1000#[repr(C)]
1001#[derive(Debug, Copy, Clone)]
1002pub struct Sz_findInterestingEntitiesByRecordID_result {
1003 pub response: *mut libc::c_char,
1004 pub returnCode: i64,
1005}
1006impl Default for Sz_findInterestingEntitiesByRecordID_result {
1007 fn default() -> Self {
1008 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1009 unsafe {
1010 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1011 s.assume_init()
1012 }
1013 }
1014}
1015#[repr(C)]
1016#[derive(Debug, Copy, Clone)]
1017pub struct Sz_findNetworkByEntityID_result {
1018 pub response: *mut libc::c_char,
1019 pub returnCode: i64,
1020}
1021impl Default for Sz_findNetworkByEntityID_result {
1022 fn default() -> Self {
1023 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1024 unsafe {
1025 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1026 s.assume_init()
1027 }
1028 }
1029}
1030#[repr(C)]
1031#[derive(Debug, Copy, Clone)]
1032pub struct Sz_findNetworkByEntityID_V2_result {
1033 pub response: *mut libc::c_char,
1034 pub returnCode: i64,
1035}
1036impl Default for Sz_findNetworkByEntityID_V2_result {
1037 fn default() -> Self {
1038 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1039 unsafe {
1040 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1041 s.assume_init()
1042 }
1043 }
1044}
1045#[repr(C)]
1046#[derive(Debug, Copy, Clone)]
1047pub struct Sz_findNetworkByRecordID_result {
1048 pub response: *mut libc::c_char,
1049 pub returnCode: i64,
1050}
1051impl Default for Sz_findNetworkByRecordID_result {
1052 fn default() -> Self {
1053 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1054 unsafe {
1055 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1056 s.assume_init()
1057 }
1058 }
1059}
1060#[repr(C)]
1061#[derive(Debug, Copy, Clone)]
1062pub struct Sz_findNetworkByRecordID_V2_result {
1063 pub response: *mut libc::c_char,
1064 pub returnCode: i64,
1065}
1066impl Default for Sz_findNetworkByRecordID_V2_result {
1067 fn default() -> Self {
1068 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1069 unsafe {
1070 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1071 s.assume_init()
1072 }
1073 }
1074}
1075#[repr(C)]
1076#[derive(Debug, Copy, Clone)]
1077pub struct Sz_findPathByEntityID_result {
1078 pub response: *mut libc::c_char,
1079 pub returnCode: i64,
1080}
1081impl Default for Sz_findPathByEntityID_result {
1082 fn default() -> Self {
1083 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1084 unsafe {
1085 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1086 s.assume_init()
1087 }
1088 }
1089}
1090#[repr(C)]
1091#[derive(Debug, Copy, Clone)]
1092pub struct Sz_findPathByEntityID_V2_result {
1093 pub response: *mut libc::c_char,
1094 pub returnCode: i64,
1095}
1096impl Default for Sz_findPathByEntityID_V2_result {
1097 fn default() -> Self {
1098 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1099 unsafe {
1100 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1101 s.assume_init()
1102 }
1103 }
1104}
1105#[repr(C)]
1106#[derive(Debug, Copy, Clone)]
1107pub struct Sz_findPathByRecordID_result {
1108 pub response: *mut libc::c_char,
1109 pub returnCode: i64,
1110}
1111impl Default for Sz_findPathByRecordID_result {
1112 fn default() -> Self {
1113 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1114 unsafe {
1115 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1116 s.assume_init()
1117 }
1118 }
1119}
1120#[repr(C)]
1121#[derive(Debug, Copy, Clone)]
1122pub struct Sz_findPathByRecordID_V2_result {
1123 pub response: *mut libc::c_char,
1124 pub returnCode: i64,
1125}
1126impl Default for Sz_findPathByRecordID_V2_result {
1127 fn default() -> Self {
1128 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1129 unsafe {
1130 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1131 s.assume_init()
1132 }
1133 }
1134}
1135#[repr(C)]
1136#[derive(Debug, Copy, Clone)]
1137pub struct Sz_findPathByEntityIDWithAvoids_result {
1138 pub response: *mut libc::c_char,
1139 pub returnCode: i64,
1140}
1141impl Default for Sz_findPathByEntityIDWithAvoids_result {
1142 fn default() -> Self {
1143 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1144 unsafe {
1145 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1146 s.assume_init()
1147 }
1148 }
1149}
1150#[repr(C)]
1151#[derive(Debug, Copy, Clone)]
1152pub struct Sz_findPathByEntityIDWithAvoids_V2_result {
1153 pub response: *mut libc::c_char,
1154 pub returnCode: i64,
1155}
1156impl Default for Sz_findPathByEntityIDWithAvoids_V2_result {
1157 fn default() -> Self {
1158 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1159 unsafe {
1160 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1161 s.assume_init()
1162 }
1163 }
1164}
1165#[repr(C)]
1166#[derive(Debug, Copy, Clone)]
1167pub struct Sz_findPathByRecordIDWithAvoids_result {
1168 pub response: *mut libc::c_char,
1169 pub returnCode: i64,
1170}
1171impl Default for Sz_findPathByRecordIDWithAvoids_result {
1172 fn default() -> Self {
1173 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1174 unsafe {
1175 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1176 s.assume_init()
1177 }
1178 }
1179}
1180#[repr(C)]
1181#[derive(Debug, Copy, Clone)]
1182pub struct Sz_findPathByRecordIDWithAvoids_V2_result {
1183 pub response: *mut libc::c_char,
1184 pub returnCode: i64,
1185}
1186impl Default for Sz_findPathByRecordIDWithAvoids_V2_result {
1187 fn default() -> Self {
1188 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1189 unsafe {
1190 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1191 s.assume_init()
1192 }
1193 }
1194}
1195#[repr(C)]
1196#[derive(Debug, Copy, Clone)]
1197pub struct Sz_findPathByEntityIDIncludingSource_result {
1198 pub response: *mut libc::c_char,
1199 pub returnCode: i64,
1200}
1201impl Default for Sz_findPathByEntityIDIncludingSource_result {
1202 fn default() -> Self {
1203 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1204 unsafe {
1205 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1206 s.assume_init()
1207 }
1208 }
1209}
1210#[repr(C)]
1211#[derive(Debug, Copy, Clone)]
1212pub struct Sz_findPathByEntityIDIncludingSource_V2_result {
1213 pub response: *mut libc::c_char,
1214 pub returnCode: i64,
1215}
1216impl Default for Sz_findPathByEntityIDIncludingSource_V2_result {
1217 fn default() -> Self {
1218 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1219 unsafe {
1220 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1221 s.assume_init()
1222 }
1223 }
1224}
1225#[repr(C)]
1226#[derive(Debug, Copy, Clone)]
1227pub struct Sz_findPathByRecordIDIncludingSource_result {
1228 pub response: *mut libc::c_char,
1229 pub returnCode: i64,
1230}
1231impl Default for Sz_findPathByRecordIDIncludingSource_result {
1232 fn default() -> Self {
1233 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1234 unsafe {
1235 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1236 s.assume_init()
1237 }
1238 }
1239}
1240#[repr(C)]
1241#[derive(Debug, Copy, Clone)]
1242pub struct Sz_findPathByRecordIDIncludingSource_V2_result {
1243 pub response: *mut libc::c_char,
1244 pub returnCode: i64,
1245}
1246impl Default for Sz_findPathByRecordIDIncludingSource_V2_result {
1247 fn default() -> Self {
1248 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1249 unsafe {
1250 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1251 s.assume_init()
1252 }
1253 }
1254}
1255#[repr(C)]
1256#[derive(Debug, Default, Copy, Clone)]
1257pub struct Sz_getActiveConfigID_result {
1258 pub configID: i64,
1259 pub returnCode: i64,
1260}
1261#[repr(C)]
1262#[derive(Debug, Copy, Clone)]
1263pub struct Sz_getEntityByEntityID_result {
1264 pub response: *mut libc::c_char,
1265 pub returnCode: i64,
1266}
1267impl Default for Sz_getEntityByEntityID_result {
1268 fn default() -> Self {
1269 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1270 unsafe {
1271 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1272 s.assume_init()
1273 }
1274 }
1275}
1276#[repr(C)]
1277#[derive(Debug, Copy, Clone)]
1278pub struct Sz_getEntityByEntityID_V2_result {
1279 pub response: *mut libc::c_char,
1280 pub returnCode: i64,
1281}
1282impl Default for Sz_getEntityByEntityID_V2_result {
1283 fn default() -> Self {
1284 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1285 unsafe {
1286 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1287 s.assume_init()
1288 }
1289 }
1290}
1291#[repr(C)]
1292#[derive(Debug, Copy, Clone)]
1293pub struct Sz_getEntityByRecordID_result {
1294 pub response: *mut libc::c_char,
1295 pub returnCode: i64,
1296}
1297impl Default for Sz_getEntityByRecordID_result {
1298 fn default() -> Self {
1299 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1300 unsafe {
1301 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1302 s.assume_init()
1303 }
1304 }
1305}
1306#[repr(C)]
1307#[derive(Debug, Copy, Clone)]
1308pub struct Sz_getEntityByRecordID_V2_result {
1309 pub response: *mut libc::c_char,
1310 pub returnCode: i64,
1311}
1312impl Default for Sz_getEntityByRecordID_V2_result {
1313 fn default() -> Self {
1314 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1315 unsafe {
1316 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1317 s.assume_init()
1318 }
1319 }
1320}
1321#[repr(C)]
1322#[derive(Debug, Copy, Clone)]
1323pub struct Sz_getRecord_result {
1324 pub response: *mut libc::c_char,
1325 pub returnCode: i64,
1326}
1327impl Default for Sz_getRecord_result {
1328 fn default() -> Self {
1329 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1330 unsafe {
1331 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1332 s.assume_init()
1333 }
1334 }
1335}
1336#[repr(C)]
1337#[derive(Debug, Copy, Clone)]
1338pub struct Sz_getRecord_V2_result {
1339 pub response: *mut libc::c_char,
1340 pub returnCode: i64,
1341}
1342impl Default for Sz_getRecord_V2_result {
1343 fn default() -> Self {
1344 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1345 unsafe {
1346 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1347 s.assume_init()
1348 }
1349 }
1350}
1351#[repr(C)]
1352#[derive(Debug, Copy, Clone)]
1353pub struct Sz_getRedoRecord_result {
1354 pub response: *mut libc::c_char,
1355 pub returnCode: i64,
1356}
1357impl Default for Sz_getRedoRecord_result {
1358 fn default() -> Self {
1359 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1360 unsafe {
1361 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1362 s.assume_init()
1363 }
1364 }
1365}
1366#[repr(C)]
1367#[derive(Debug, Copy, Clone)]
1368pub struct Sz_getVirtualEntityByRecordID_result {
1369 pub response: *mut libc::c_char,
1370 pub returnCode: i64,
1371}
1372impl Default for Sz_getVirtualEntityByRecordID_result {
1373 fn default() -> Self {
1374 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1375 unsafe {
1376 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1377 s.assume_init()
1378 }
1379 }
1380}
1381#[repr(C)]
1382#[derive(Debug, Copy, Clone)]
1383pub struct Sz_getVirtualEntityByRecordID_V2_result {
1384 pub response: *mut libc::c_char,
1385 pub returnCode: i64,
1386}
1387impl Default for Sz_getVirtualEntityByRecordID_V2_result {
1388 fn default() -> Self {
1389 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1390 unsafe {
1391 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1392 s.assume_init()
1393 }
1394 }
1395}
1396#[repr(C)]
1397#[derive(Debug, Copy, Clone)]
1398pub struct Sz_howEntityByEntityID_result {
1399 pub response: *mut libc::c_char,
1400 pub returnCode: i64,
1401}
1402impl Default for Sz_howEntityByEntityID_result {
1403 fn default() -> Self {
1404 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1405 unsafe {
1406 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1407 s.assume_init()
1408 }
1409 }
1410}
1411#[repr(C)]
1412#[derive(Debug, Copy, Clone)]
1413pub struct Sz_howEntityByEntityID_V2_result {
1414 pub response: *mut libc::c_char,
1415 pub returnCode: i64,
1416}
1417impl Default for Sz_howEntityByEntityID_V2_result {
1418 fn default() -> Self {
1419 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1420 unsafe {
1421 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1422 s.assume_init()
1423 }
1424 }
1425}
1426#[repr(C)]
1427#[derive(Debug, Copy, Clone)]
1428pub struct Sz_reevaluateEntityWithInfo_result {
1429 pub response: *mut libc::c_char,
1430 pub returnCode: i64,
1431}
1432impl Default for Sz_reevaluateEntityWithInfo_result {
1433 fn default() -> Self {
1434 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1435 unsafe {
1436 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1437 s.assume_init()
1438 }
1439 }
1440}
1441#[repr(C)]
1442#[derive(Debug, Copy, Clone)]
1443pub struct Sz_reevaluateRecordWithInfo_result {
1444 pub response: *mut libc::c_char,
1445 pub returnCode: i64,
1446}
1447impl Default for Sz_reevaluateRecordWithInfo_result {
1448 fn default() -> Self {
1449 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1450 unsafe {
1451 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1452 s.assume_init()
1453 }
1454 }
1455}
1456#[repr(C)]
1457#[derive(Debug, Copy, Clone)]
1458pub struct Sz_getRecordPreview_result {
1459 pub response: *mut libc::c_char,
1460 pub returnCode: i64,
1461}
1462impl Default for Sz_getRecordPreview_result {
1463 fn default() -> Self {
1464 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1465 unsafe {
1466 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1467 s.assume_init()
1468 }
1469 }
1470}
1471#[repr(C)]
1472#[derive(Debug, Copy, Clone)]
1473pub struct Sz_searchByAttributes_result {
1474 pub response: *mut libc::c_char,
1475 pub returnCode: i64,
1476}
1477impl Default for Sz_searchByAttributes_result {
1478 fn default() -> Self {
1479 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1480 unsafe {
1481 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1482 s.assume_init()
1483 }
1484 }
1485}
1486#[repr(C)]
1487#[derive(Debug, Copy, Clone)]
1488pub struct Sz_searchByAttributes_V2_result {
1489 pub response: *mut libc::c_char,
1490 pub returnCode: i64,
1491}
1492impl Default for Sz_searchByAttributes_V2_result {
1493 fn default() -> Self {
1494 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1495 unsafe {
1496 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1497 s.assume_init()
1498 }
1499 }
1500}
1501#[repr(C)]
1502#[derive(Debug, Copy, Clone)]
1503pub struct Sz_searchByAttributes_V3_result {
1504 pub response: *mut libc::c_char,
1505 pub returnCode: i64,
1506}
1507impl Default for Sz_searchByAttributes_V3_result {
1508 fn default() -> Self {
1509 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1510 unsafe {
1511 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1512 s.assume_init()
1513 }
1514 }
1515}
1516#[repr(C)]
1517#[derive(Debug, Copy, Clone)]
1518pub struct Sz_stats_result {
1519 pub response: *mut libc::c_char,
1520 pub returnCode: i64,
1521}
1522impl Default for Sz_stats_result {
1523 fn default() -> Self {
1524 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1525 unsafe {
1526 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1527 s.assume_init()
1528 }
1529 }
1530}
1531#[repr(C)]
1532#[derive(Debug, Copy, Clone)]
1533pub struct Sz_whySearch_result {
1534 pub response: *mut libc::c_char,
1535 pub returnCode: i64,
1536}
1537impl Default for Sz_whySearch_result {
1538 fn default() -> Self {
1539 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1540 unsafe {
1541 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1542 s.assume_init()
1543 }
1544 }
1545}
1546#[repr(C)]
1547#[derive(Debug, Copy, Clone)]
1548pub struct Sz_whySearch_V2_result {
1549 pub response: *mut libc::c_char,
1550 pub returnCode: i64,
1551}
1552impl Default for Sz_whySearch_V2_result {
1553 fn default() -> Self {
1554 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1555 unsafe {
1556 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1557 s.assume_init()
1558 }
1559 }
1560}
1561#[repr(C)]
1562#[derive(Debug, Copy, Clone)]
1563pub struct Sz_whyEntities_result {
1564 pub response: *mut libc::c_char,
1565 pub returnCode: i64,
1566}
1567impl Default for Sz_whyEntities_result {
1568 fn default() -> Self {
1569 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1570 unsafe {
1571 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1572 s.assume_init()
1573 }
1574 }
1575}
1576#[repr(C)]
1577#[derive(Debug, Copy, Clone)]
1578pub struct Sz_whyEntities_V2_result {
1579 pub response: *mut libc::c_char,
1580 pub returnCode: i64,
1581}
1582impl Default for Sz_whyEntities_V2_result {
1583 fn default() -> Self {
1584 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1585 unsafe {
1586 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1587 s.assume_init()
1588 }
1589 }
1590}
1591#[repr(C)]
1592#[derive(Debug, Copy, Clone)]
1593pub struct Sz_whyRecords_result {
1594 pub response: *mut libc::c_char,
1595 pub returnCode: i64,
1596}
1597impl Default for Sz_whyRecords_result {
1598 fn default() -> Self {
1599 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1600 unsafe {
1601 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1602 s.assume_init()
1603 }
1604 }
1605}
1606#[repr(C)]
1607#[derive(Debug, Copy, Clone)]
1608pub struct Sz_whyRecords_V2_result {
1609 pub response: *mut libc::c_char,
1610 pub returnCode: i64,
1611}
1612impl Default for Sz_whyRecords_V2_result {
1613 fn default() -> Self {
1614 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1615 unsafe {
1616 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1617 s.assume_init()
1618 }
1619 }
1620}
1621#[repr(C)]
1622#[derive(Debug, Copy, Clone)]
1623pub struct Sz_whyRecordInEntity_result {
1624 pub response: *mut libc::c_char,
1625 pub returnCode: i64,
1626}
1627impl Default for Sz_whyRecordInEntity_result {
1628 fn default() -> Self {
1629 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1630 unsafe {
1631 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1632 s.assume_init()
1633 }
1634 }
1635}
1636#[repr(C)]
1637#[derive(Debug, Copy, Clone)]
1638pub struct Sz_whyRecordInEntity_V2_result {
1639 pub response: *mut libc::c_char,
1640 pub returnCode: i64,
1641}
1642impl Default for Sz_whyRecordInEntity_V2_result {
1643 fn default() -> Self {
1644 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1645 unsafe {
1646 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1647 s.assume_init()
1648 }
1649 }
1650}
1651unsafe extern "C" {
1652 pub fn Sz_addRecordWithInfo_helper(
1653 dataSourceCode: *const libc::c_char,
1654 recordID: *const libc::c_char,
1655 jsonData: *const libc::c_char,
1656 flags: i64,
1657 ) -> Sz_addRecordWithInfo_result;
1658}
1659unsafe extern "C" {
1660 pub fn Sz_processRedoRecordWithInfo_helper(
1661 jsonData: *const libc::c_char,
1662 ) -> Sz_processRedoRecordWithInfo_result;
1663}
1664unsafe extern "C" {
1665 pub fn Sz_closeExportReport_helper(responseHandle: usize) -> i64;
1666}
1667unsafe extern "C" {
1668 pub fn Sz_deleteRecordWithInfo_helper(
1669 dataSourceCode: *const libc::c_char,
1670 recordID: *const libc::c_char,
1671 flags: i64,
1672 ) -> Sz_deleteRecordWithInfo_result;
1673}
1674unsafe extern "C" {
1675 pub fn Sz_exportCSVEntityReport_helper(
1676 csvColumnList: *const libc::c_char,
1677 flags: i64,
1678 ) -> Sz_exportCSVEntityReport_result;
1679}
1680unsafe extern "C" {
1681 pub fn Sz_exportJSONEntityReport_helper(flags: i64) -> Sz_exportJSONEntityReport_result;
1682}
1683unsafe extern "C" {
1684 pub fn Sz_findInterestingEntitiesByEntityID_helper(
1685 entityID: i64,
1686 flags: i64,
1687 ) -> Sz_findInterestingEntitiesByEntityID_result;
1688}
1689unsafe extern "C" {
1690 pub fn Sz_findInterestingEntitiesByRecordID_helper(
1691 dataSourceCode: *const libc::c_char,
1692 recordID: *const libc::c_char,
1693 flags: i64,
1694 ) -> Sz_findInterestingEntitiesByRecordID_result;
1695}
1696unsafe extern "C" {
1697 pub fn Sz_findNetworkByEntityID_helper(
1698 entityList: *const libc::c_char,
1699 maxDegree: i64,
1700 buildOutDegree: i64,
1701 maxEntities: i64,
1702 ) -> Sz_findNetworkByEntityID_result;
1703}
1704unsafe extern "C" {
1705 pub fn Sz_findNetworkByEntityID_V2_helper(
1706 entityList: *const libc::c_char,
1707 maxDegree: i64,
1708 buildOutDegree: i64,
1709 maxEntities: i64,
1710 flags: i64,
1711 ) -> Sz_findNetworkByEntityID_V2_result;
1712}
1713unsafe extern "C" {
1714 pub fn Sz_findNetworkByRecordID_helper(
1715 recordList: *const libc::c_char,
1716 maxDegree: i64,
1717 buildOutDegree: i64,
1718 maxEntities: i64,
1719 ) -> Sz_findNetworkByRecordID_result;
1720}
1721unsafe extern "C" {
1722 pub fn Sz_findNetworkByRecordID_V2_helper(
1723 recordList: *const libc::c_char,
1724 maxDegree: i64,
1725 buildOutDegree: i64,
1726 maxEntities: i64,
1727 flags: i64,
1728 ) -> Sz_findNetworkByRecordID_V2_result;
1729}
1730unsafe extern "C" {
1731 pub fn Sz_findPathByEntityID_helper(
1732 entityID1: i64,
1733 entityID2: i64,
1734 maxDegree: i64,
1735 ) -> Sz_findPathByEntityID_result;
1736}
1737unsafe extern "C" {
1738 pub fn Sz_findPathByEntityID_V2_helper(
1739 entityID1: i64,
1740 entityID2: i64,
1741 maxDegree: i64,
1742 flags: i64,
1743 ) -> Sz_findPathByEntityID_V2_result;
1744}
1745unsafe extern "C" {
1746 pub fn Sz_findPathByRecordID_helper(
1747 dataSourceCode1: *const libc::c_char,
1748 recordID1: *const libc::c_char,
1749 dataSourceCode2: *const libc::c_char,
1750 recordID2: *const libc::c_char,
1751 maxDegree: i64,
1752 ) -> Sz_findPathByRecordID_result;
1753}
1754unsafe extern "C" {
1755 pub fn Sz_findPathByRecordID_V2_helper(
1756 dataSourceCode1: *const libc::c_char,
1757 recordID1: *const libc::c_char,
1758 dataSourceCode2: *const libc::c_char,
1759 recordID2: *const libc::c_char,
1760 maxDegree: i64,
1761 flags: i64,
1762 ) -> Sz_findPathByRecordID_V2_result;
1763}
1764unsafe extern "C" {
1765 pub fn Sz_findPathByEntityIDWithAvoids_helper(
1766 entityID1: i64,
1767 entityID2: i64,
1768 maxDegree: i64,
1769 avoidedEntities: *const libc::c_char,
1770 ) -> Sz_findPathByEntityIDWithAvoids_result;
1771}
1772unsafe extern "C" {
1773 pub fn Sz_findPathByEntityIDWithAvoids_V2_helper(
1774 entityID1: i64,
1775 entityID2: i64,
1776 maxDegree: i64,
1777 avoidedEntities: *const libc::c_char,
1778 flags: i64,
1779 ) -> Sz_findPathByEntityIDWithAvoids_V2_result;
1780}
1781unsafe extern "C" {
1782 pub fn Sz_findPathByRecordIDWithAvoids_helper(
1783 dataSourceCode1: *const libc::c_char,
1784 recordID1: *const libc::c_char,
1785 dataSourceCode2: *const libc::c_char,
1786 recordID2: *const libc::c_char,
1787 maxDegree: i64,
1788 avoidedRecords: *const libc::c_char,
1789 ) -> Sz_findPathByRecordIDWithAvoids_result;
1790}
1791unsafe extern "C" {
1792 pub fn Sz_findPathByRecordIDWithAvoids_V2_helper(
1793 dataSourceCode1: *const libc::c_char,
1794 recordID1: *const libc::c_char,
1795 dataSourceCode2: *const libc::c_char,
1796 recordID2: *const libc::c_char,
1797 maxDegree: i64,
1798 avoidedRecords: *const libc::c_char,
1799 flags: i64,
1800 ) -> Sz_findPathByRecordIDWithAvoids_V2_result;
1801}
1802unsafe extern "C" {
1803 pub fn Sz_findPathByEntityIDIncludingSource_helper(
1804 entityID1: i64,
1805 entityID2: i64,
1806 maxDegree: i64,
1807 avoidedEntities: *const libc::c_char,
1808 requiredDsrcs: *const libc::c_char,
1809 ) -> Sz_findPathByEntityIDIncludingSource_result;
1810}
1811unsafe extern "C" {
1812 pub fn Sz_findPathByEntityIDIncludingSource_V2_helper(
1813 entityID1: i64,
1814 entityID2: i64,
1815 maxDegree: i64,
1816 avoidedEntities: *const libc::c_char,
1817 requiredDsrcs: *const libc::c_char,
1818 flags: i64,
1819 ) -> Sz_findPathByEntityIDIncludingSource_V2_result;
1820}
1821unsafe extern "C" {
1822 pub fn Sz_findPathByRecordIDIncludingSource_helper(
1823 dataSourceCode1: *const libc::c_char,
1824 recordID1: *const libc::c_char,
1825 dataSourceCode2: *const libc::c_char,
1826 recordID2: *const libc::c_char,
1827 maxDegree: i64,
1828 avoidedRecords: *const libc::c_char,
1829 requiredDsrcs: *const libc::c_char,
1830 ) -> Sz_findPathByRecordIDIncludingSource_result;
1831}
1832unsafe extern "C" {
1833 pub fn Sz_findPathByRecordIDIncludingSource_V2_helper(
1834 dataSourceCode1: *const libc::c_char,
1835 recordID1: *const libc::c_char,
1836 dataSourceCode2: *const libc::c_char,
1837 recordID2: *const libc::c_char,
1838 maxDegree: i64,
1839 avoidedRecords: *const libc::c_char,
1840 requiredDsrcs: *const libc::c_char,
1841 flags: i64,
1842 ) -> Sz_findPathByRecordIDIncludingSource_V2_result;
1843}
1844unsafe extern "C" {
1845 pub fn Sz_fetchNext_helper(exportHandle: usize) -> Sz_fetchNext_result;
1846}
1847unsafe extern "C" {
1848 pub fn Sz_getActiveConfigID_helper() -> Sz_getActiveConfigID_result;
1849}
1850unsafe extern "C" {
1851 pub fn Sz_getEntityByEntityID_helper(entityID: i64) -> Sz_getEntityByEntityID_result;
1852}
1853unsafe extern "C" {
1854 pub fn Sz_getEntityByEntityID_V2_helper(
1855 entityID: i64,
1856 flags: i64,
1857 ) -> Sz_getEntityByEntityID_V2_result;
1858}
1859unsafe extern "C" {
1860 pub fn Sz_getEntityByRecordID_helper(
1861 dataSourceCode: *const libc::c_char,
1862 recordID: *const libc::c_char,
1863 ) -> Sz_getEntityByRecordID_result;
1864}
1865unsafe extern "C" {
1866 pub fn Sz_getEntityByRecordID_V2_helper(
1867 dataSourceCode: *const libc::c_char,
1868 recordID: *const libc::c_char,
1869 flags: i64,
1870 ) -> Sz_getEntityByRecordID_V2_result;
1871}
1872unsafe extern "C" {
1873 pub fn Sz_getRecord_helper(
1874 dataSourceCode: *const libc::c_char,
1875 recordID: *const libc::c_char,
1876 ) -> Sz_getRecord_result;
1877}
1878unsafe extern "C" {
1879 pub fn Sz_getRecord_V2_helper(
1880 dataSourceCode: *const libc::c_char,
1881 recordID: *const libc::c_char,
1882 flags: i64,
1883 ) -> Sz_getRecord_V2_result;
1884}
1885unsafe extern "C" {
1886 pub fn Sz_getRedoRecord_helper() -> Sz_getRedoRecord_result;
1887}
1888unsafe extern "C" {
1889 pub fn Sz_getVirtualEntityByRecordID_helper(
1890 recordList: *const libc::c_char,
1891 ) -> Sz_getVirtualEntityByRecordID_result;
1892}
1893unsafe extern "C" {
1894 pub fn Sz_getVirtualEntityByRecordID_V2_helper(
1895 recordList: *const libc::c_char,
1896 flags: i64,
1897 ) -> Sz_getVirtualEntityByRecordID_V2_result;
1898}
1899unsafe extern "C" {
1900 pub fn Sz_howEntityByEntityID_helper(entityID: i64) -> Sz_howEntityByEntityID_result;
1901}
1902unsafe extern "C" {
1903 pub fn Sz_howEntityByEntityID_V2_helper(
1904 entityID: i64,
1905 flags: i64,
1906 ) -> Sz_howEntityByEntityID_V2_result;
1907}
1908unsafe extern "C" {
1909 pub fn Sz_reevaluateEntityWithInfo_helper(
1910 entityID: i64,
1911 flags: i64,
1912 ) -> Sz_reevaluateEntityWithInfo_result;
1913}
1914unsafe extern "C" {
1915 pub fn Sz_reevaluateRecordWithInfo_helper(
1916 dataSourceCode: *const libc::c_char,
1917 recordID: *const libc::c_char,
1918 flags: i64,
1919 ) -> Sz_reevaluateRecordWithInfo_result;
1920}
1921unsafe extern "C" {
1922 pub fn Sz_getRecordPreview_helper(
1923 jsonData: *const libc::c_char,
1924 flags: i64,
1925 ) -> Sz_getRecordPreview_result;
1926}
1927unsafe extern "C" {
1928 pub fn Sz_searchByAttributes_helper(
1929 jsonData: *const libc::c_char,
1930 ) -> Sz_searchByAttributes_result;
1931}
1932unsafe extern "C" {
1933 pub fn Sz_searchByAttributes_V2_helper(
1934 jsonData: *const libc::c_char,
1935 flags: i64,
1936 ) -> Sz_searchByAttributes_V2_result;
1937}
1938unsafe extern "C" {
1939 pub fn Sz_searchByAttributes_V3_helper(
1940 jsonData: *const libc::c_char,
1941 profile: *const libc::c_char,
1942 flags: i64,
1943 ) -> Sz_searchByAttributes_V3_result;
1944}
1945unsafe extern "C" {
1946 pub fn Sz_stats_helper() -> Sz_stats_result;
1947}
1948unsafe extern "C" {
1949 pub fn Sz_whySearch_helper(
1950 jsonData: *const libc::c_char,
1951 entityID: i64,
1952 searchProfile: *const libc::c_char,
1953 ) -> Sz_whySearch_result;
1954}
1955unsafe extern "C" {
1956 pub fn Sz_whySearch_V2_helper(
1957 jsonData: *const libc::c_char,
1958 entityID: i64,
1959 searchProfile: *const libc::c_char,
1960 flags: i64,
1961 ) -> Sz_whySearch_V2_result;
1962}
1963unsafe extern "C" {
1964 pub fn Sz_whyEntities_helper(entityID1: i64, entityID2: i64) -> Sz_whyEntities_result;
1965}
1966unsafe extern "C" {
1967 pub fn Sz_whyEntities_V2_helper(
1968 entityID1: i64,
1969 entityID2: i64,
1970 flags: i64,
1971 ) -> Sz_whyEntities_V2_result;
1972}
1973unsafe extern "C" {
1974 pub fn Sz_whyRecords_helper(
1975 dataSourceCode1: *const libc::c_char,
1976 recordID1: *const libc::c_char,
1977 dataSourceCode2: *const libc::c_char,
1978 recordID2: *const libc::c_char,
1979 ) -> Sz_whyRecords_result;
1980}
1981unsafe extern "C" {
1982 pub fn Sz_whyRecords_V2_helper(
1983 dataSourceCode1: *const libc::c_char,
1984 recordID1: *const libc::c_char,
1985 dataSourceCode2: *const libc::c_char,
1986 recordID2: *const libc::c_char,
1987 flags: i64,
1988 ) -> Sz_whyRecords_V2_result;
1989}
1990unsafe extern "C" {
1991 pub fn Sz_whyRecordInEntity_helper(
1992 dataSourceCode: *const libc::c_char,
1993 recordID: *const libc::c_char,
1994 ) -> Sz_whyRecordInEntity_result;
1995}
1996unsafe extern "C" {
1997 pub fn Sz_whyRecordInEntity_V2_helper(
1998 dataSourceCode: *const libc::c_char,
1999 recordID: *const libc::c_char,
2000 flags: i64,
2001 ) -> Sz_whyRecordInEntity_V2_result;
2002}
2003#[repr(C)]
2004#[derive(Debug, Copy, Clone)]
2005pub struct SzProduct_validateLicenseFile_result {
2006 pub response: *mut libc::c_char,
2007 pub returnCode: i64,
2008}
2009impl Default for SzProduct_validateLicenseFile_result {
2010 fn default() -> Self {
2011 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
2012 unsafe {
2013 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2014 s.assume_init()
2015 }
2016 }
2017}
2018#[repr(C)]
2019#[derive(Debug, Copy, Clone)]
2020pub struct SzProduct_validateLicenseStringBase64_result {
2021 pub response: *mut libc::c_char,
2022 pub returnCode: i64,
2023}
2024impl Default for SzProduct_validateLicenseStringBase64_result {
2025 fn default() -> Self {
2026 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
2027 unsafe {
2028 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2029 s.assume_init()
2030 }
2031 }
2032}
2033unsafe extern "C" {
2034 pub fn SzProduct_validateLicenseFile_helper(
2035 licenseFilePath: *const libc::c_char,
2036 ) -> SzProduct_validateLicenseFile_result;
2037}
2038unsafe extern "C" {
2039 pub fn SzProduct_validateLicenseStringBase64_helper(
2040 licenseString: *const libc::c_char,
2041 ) -> SzProduct_validateLicenseStringBase64_result;
2042}
2043unsafe extern "C" {
2044 #[doc = " @brief\n This method will initialize the SzConfig object. It must be called\n prior to any other calls.\n\n @param moduleName A name for the engine node, to help identify it within\n system logs.\n @param iniParams A JSON string containing configuration parameters.\n @param verboseLogging A flag to enable deeper logging of the Sz processing"]
2045 pub fn SzConfig_init(
2046 moduleName: *const libc::c_char,
2047 iniParams: *const libc::c_char,
2048 verboseLogging: i64,
2049 ) -> i64;
2050}
2051unsafe extern "C" {
2052 #[doc = " @brief\n This method will destroy and perform cleanup for the Sz Config object. It\n should be called after all other calls are complete."]
2053 pub fn SzConfig_destroy() -> i64;
2054}
2055pub type ConfigHandle = *mut libc::c_void;
2056unsafe extern "C" {
2057 #[doc = " @brief\n This method creates a stock Sz JSON config from the template config"]
2058 pub fn SzConfig_create(configHandle: *mut ConfigHandle) -> i64;
2059}
2060unsafe extern "C" {
2061 #[doc = " @brief\n This method initializes the SzConfig object from a JSON string. Any time you need to edit an existing\n config from an existing repository you will want to use this method to be able to modify it."]
2062 pub fn SzConfig_load(jsonConfig: *const libc::c_char, configHandle: *mut ConfigHandle) -> i64;
2063}
2064unsafe extern "C" {
2065 #[doc = " @brief\n This method saves the SzConfig object into a JSON string."]
2066 pub fn SzConfig_export(
2067 configHandle: ConfigHandle,
2068 responseBuf: *mut *mut libc::c_char,
2069 bufSize: *mut usize,
2070 resizeFunc: ::core::option::Option<
2071 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
2072 >,
2073 ) -> i64;
2074}
2075unsafe extern "C" {
2076 #[doc = " @brief\n This method cleans up the SzConfig object pointed to by the handle."]
2077 pub fn SzConfig_close(configHandle: ConfigHandle) -> i64;
2078}
2079unsafe extern "C" {
2080 pub fn SzConfig_getDataSourceRegistry(
2081 configHandle: ConfigHandle,
2082 responseBuf: *mut *mut libc::c_char,
2083 bufSize: *mut usize,
2084 resizeFunc: ::core::option::Option<
2085 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
2086 >,
2087 ) -> i64;
2088}
2089unsafe extern "C" {
2090 pub fn SzConfig_registerDataSource(
2091 configHandle: ConfigHandle,
2092 inputJson: *const libc::c_char,
2093 responseBuf: *mut *mut libc::c_char,
2094 bufSize: *mut usize,
2095 resizeFunc: ::core::option::Option<
2096 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
2097 >,
2098 ) -> i64;
2099}
2100unsafe extern "C" {
2101 pub fn SzConfig_unregisterDataSource(
2102 configHandle: ConfigHandle,
2103 inputJson: *const libc::c_char,
2104 ) -> i64;
2105}
2106unsafe extern "C" {
2107 #[doc = " @brief\n This function retrieves the last exception thrown in SzConfig\n @return number of bytes copied into buffer"]
2108 pub fn SzConfig_getLastException(buffer: *mut libc::c_char, bufSize: usize) -> i64;
2109}
2110unsafe extern "C" {
2111 #[doc = " @brief\n This function retrieves the code of the last exception thrown in SzConfig\n @return number of bytes copied into buffer"]
2112 pub fn SzConfig_getLastExceptionCode() -> i64;
2113}
2114unsafe extern "C" {
2115 #[doc = " @brief\n This function clears the last exception thrown in SzConfig"]
2116 pub fn SzConfig_clearLastException();
2117}
2118unsafe extern "C" {
2119 #[doc = " @brief\n This method will initialize the Sz Config Manager object. It must be called\n prior to any other calls.\n\n @param moduleName A name for the node, to help identify it within\n system logs.\n @param iniParams A JSON string specifying the configuration parameters\n @param verboseLogging A flag to enable deeper logging of the Sz processing"]
2120 pub fn SzConfigMgr_init(
2121 moduleName: *const libc::c_char,
2122 iniParams: *const libc::c_char,
2123 verboseLogging: i64,
2124 ) -> i64;
2125}
2126unsafe extern "C" {
2127 #[doc = " @brief\n This method will destroy and perform cleanup for the Sz Config object. It\n should be called after all other calls are complete."]
2128 pub fn SzConfigMgr_destroy() -> i64;
2129}
2130unsafe extern "C" {
2131 #[doc = " @brief Registers a configuration handle with the backend data store"]
2132 pub fn SzConfigMgr_registerConfig(
2133 configStr: *const libc::c_char,
2134 configComments: *const libc::c_char,
2135 configID: *mut i64,
2136 ) -> i64;
2137}
2138unsafe extern "C" {
2139 #[doc = " @brief Retrieve configuration information from the backend data store"]
2140 pub fn SzConfigMgr_getConfig(
2141 configID: i64,
2142 responseBuf: *mut *mut libc::c_char,
2143 bufSize: *mut usize,
2144 resizeFunc: ::core::option::Option<
2145 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
2146 >,
2147 ) -> i64;
2148}
2149unsafe extern "C" {
2150 #[doc = " @brief Retrieve a list of configurations from the backend data store"]
2151 pub fn SzConfigMgr_getConfigRegistry(
2152 responseBuf: *mut *mut libc::c_char,
2153 bufSize: *mut usize,
2154 resizeFunc: ::core::option::Option<
2155 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
2156 >,
2157 ) -> i64;
2158}
2159unsafe extern "C" {
2160 #[doc = " @brief Set the default configuration identifier in the backend data store"]
2161 pub fn SzConfigMgr_setDefaultConfigID(configID: i64) -> i64;
2162}
2163unsafe extern "C" {
2164 #[doc = " @brief Get the default configuration identifier from the backend data store"]
2165 pub fn SzConfigMgr_getDefaultConfigID(configID: *mut i64) -> i64;
2166}
2167unsafe extern "C" {
2168 #[doc = " @brief Replace the default configuration identifier in the backend data store"]
2169 pub fn SzConfigMgr_replaceDefaultConfigID(oldConfigID: i64, newConfigID: i64) -> i64;
2170}
2171unsafe extern "C" {
2172 #[doc = " @brief\n This function retrieves the last exception thrown in SzConfigMgr\n @return number of bytes copied into buffer"]
2173 pub fn SzConfigMgr_getLastException(buffer: *mut libc::c_char, bufSize: usize) -> i64;
2174}
2175unsafe extern "C" {
2176 #[doc = " @brief\n This function retrieves the code of the last exception thrown in SzConfigMgr\n @return number of bytes copied into buffer"]
2177 pub fn SzConfigMgr_getLastExceptionCode() -> i64;
2178}
2179unsafe extern "C" {
2180 #[doc = " @brief\n This function clears the last exception thrown in SzConfigMgr"]
2181 pub fn SzConfigMgr_clearLastException();
2182}
2183unsafe extern "C" {
2184 #[doc = " @brief\n This method will initialize the Sz diagnostic object. It must be called\n prior to any other calls.\n\n @param moduleName A name for the diagnostic node, to help identify it within\n system logs.\n @param iniParams A JSON string specifying the configuration parameters\n @param verboseLogging A flag to enable deeper logging of the Sz processing"]
2185 pub fn SzDiagnostic_init(
2186 moduleName: *const libc::c_char,
2187 iniParams: *const libc::c_char,
2188 verboseLogging: i64,
2189 ) -> i64;
2190}
2191unsafe extern "C" {
2192 pub fn SzDiagnostic_initWithConfigID(
2193 moduleName: *const libc::c_char,
2194 iniParams: *const libc::c_char,
2195 initConfigID: i64,
2196 verboseLogging: i64,
2197 ) -> i64;
2198}
2199unsafe extern "C" {
2200 #[doc = " @brief\n This method will re-initialize the Sz diagnostic object."]
2201 pub fn SzDiagnostic_reinit(initConfigID: i64) -> i64;
2202}
2203unsafe extern "C" {
2204 #[doc = " @brief\n This method will destroy and perform cleanup for the Sz diagnostic object. It\n should be called after all other calls are complete."]
2205 pub fn SzDiagnostic_destroy() -> i64;
2206}
2207unsafe extern "C" {
2208 #[doc = " @brief\n This is used to purge all data from an existing repository\n @return Returns 0 for success, or an appropriate error code."]
2209 pub fn SzDiagnostic_purgeRepository() -> i64;
2210}
2211unsafe extern "C" {
2212 #[doc = " @brief Check the performance metrics of the datastore"]
2213 pub fn SzDiagnostic_checkRepositoryPerformance(
2214 secondsToRun: i64,
2215 responseBuf: *mut *mut libc::c_char,
2216 bufSize: *mut usize,
2217 resizeFunc: ::core::option::Option<
2218 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
2219 >,
2220 ) -> i64;
2221}
2222unsafe extern "C" {
2223 pub fn SzDiagnostic_getRepositoryInfo(
2224 responseBuf: *mut *mut libc::c_char,
2225 bufSize: *mut usize,
2226 resizeFunc: ::core::option::Option<
2227 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
2228 >,
2229 ) -> i64;
2230}
2231unsafe extern "C" {
2232 #[doc = " @brief\n This function retrieves the last exception thrown in SzDiagnostic\n @return number of bytes copied into buffer"]
2233 pub fn SzDiagnostic_getLastException(buffer: *mut libc::c_char, bufSize: usize) -> i64;
2234}
2235unsafe extern "C" {
2236 #[doc = " @brief\n This function retrieves the code of the last exception thrown in SzDiagnostic\n @return number of bytes copied into buffer"]
2237 pub fn SzDiagnostic_getLastExceptionCode() -> i64;
2238}
2239unsafe extern "C" {
2240 #[doc = " @brief\n This function clears the last exception thrown in SzDiagnostic"]
2241 pub fn SzDiagnostic_clearLastException();
2242}
2243unsafe extern "C" {
2244 #[doc = " THESE FUNCTIONS ARE UNSUPPORTED AND UNDOCUMENTED. ANY USE IS WITHOUT WARRANTY OF ANY KIND."]
2245 pub fn SzDiagnostic_getFeature(
2246 libFeatID: i64,
2247 responseBuf: *mut *mut libc::c_char,
2248 bufSize: *mut usize,
2249 resizeFunc: ::core::option::Option<
2250 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
2251 >,
2252 ) -> i64;
2253}
2254unsafe extern "C" {
2255 #[doc = " @brief\n This method will initialize the Sz product object. It must be called\n prior to any other calls.\n\n @param moduleName A name for the node, to help identify it within\n system logs.\n @param iniParams A JSON string specifying the configuration parameters\n @param verboseLogging A flag to enable deeper logging of the Sz processing"]
2256 pub fn SzProduct_init(
2257 moduleName: *const libc::c_char,
2258 iniParams: *const libc::c_char,
2259 verboseLogging: i64,
2260 ) -> i64;
2261}
2262unsafe extern "C" {
2263 #[doc = " @brief\n This method will destroy and perform cleanup for the Sz product object. It\n should be called after all other calls are complete."]
2264 pub fn SzProduct_destroy() -> i64;
2265}
2266unsafe extern "C" {
2267 #[doc = " @brief\n This function is used to return the license information\n\n @return Returns a pointer to the license information in JSON format"]
2268 pub fn SzProduct_getLicense() -> *mut libc::c_char;
2269}
2270unsafe extern "C" {
2271 #[doc = " @brief\n This function is used to validate an external license file for validity.\n If it is not valid, information on why will be returned through the\n error buffer parameters.\n\n These functions do not require SzProduct to be initialized.\n\n @param licenseFilePath The file path and name of the file to validate.\n @param errorBuf The buffer to write an error message to\n @param errorBufSize The size of the error buffer\n @param resizeFunc A function to resize the error buffer, if it needs more space.\n\n @return 0 if the file is a valid license."]
2272 pub fn SzProduct_validateLicenseFile(
2273 licenseFilePath: *const libc::c_char,
2274 errorBuf: *mut *mut libc::c_char,
2275 errorBufSize: *mut usize,
2276 resizeFunc: ::core::option::Option<
2277 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
2278 >,
2279 ) -> i64;
2280}
2281unsafe extern "C" {
2282 pub fn SzProduct_validateLicenseStringBase64(
2283 licenseString: *const libc::c_char,
2284 errorBuf: *mut *mut libc::c_char,
2285 errorBufSize: *mut usize,
2286 resizeFunc: ::core::option::Option<
2287 unsafe extern "C" fn(ptr: *mut libc::c_void, newSize: usize) -> *mut libc::c_void,
2288 >,
2289 ) -> i64;
2290}
2291unsafe extern "C" {
2292 #[doc = " @brief\n This function is used to return the version and build information\n\n This function does not require SzProduct to be initialized.\n\n @return Returns a pointer to the version and build information in JSON format"]
2293 pub fn SzProduct_getVersion() -> *mut libc::c_char;
2294}
2295unsafe extern "C" {
2296 #[doc = " @brief\n This function retrieves the last exception thrown in SzProduct\n @return number of bytes copied into buffer"]
2297 pub fn SzProduct_getLastException(buffer: *mut libc::c_char, bufSize: usize) -> i64;
2298}
2299unsafe extern "C" {
2300 #[doc = " @brief\n This function retrieves the code of the last exception thrown in SzProduct\n @return number of bytes copied into buffer"]
2301 pub fn SzProduct_getLastExceptionCode() -> i64;
2302}
2303unsafe extern "C" {
2304 #[doc = " @brief\n This function clears the last exception thrown in SzProduct"]
2305 pub fn SzProduct_clearLastException();
2306}