Add *~ to .gitignore
[vala-lang.git] / vapi / libsoup-2.4.vapi
blobaeda1e4d1e1aa8dd719aa918b2dba5a7a8bddd52
1 /* libsoup-2.4.vapi generated by vapigen, do not modify. */
3 [CCode (cprefix = "Soup", lower_case_cprefix = "soup_")]
4 namespace Soup {
5         [CCode (cprefix = "SoupXMLRPC", lower_case_cprefix = "soup_xmlrpc_")]
6         namespace XMLRPC {
7                 [CCode (cprefix = "SOUP_XMLRPC_ERROR_", cheader_filename = "libsoup/soup.h")]
8                 public errordomain Error {
9                         ARGUMENTS,
10                         RETVAL,
11                 }
12                 [CCode (cprefix = "SOUP_XMLRPC_FAULT_", cheader_filename = "libsoup/soup.h")]
13                 public errordomain Fault {
14                         PARSE_ERROR_NOT_WELL_FORMED,
15                         PARSE_ERROR_UNSUPPORTED_ENCODING,
16                         PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING,
17                         SERVER_ERROR_INVALID_XML_RPC,
18                         SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND,
19                         SERVER_ERROR_INVALID_METHOD_PARAMETERS,
20                         SERVER_ERROR_INTERNAL_XML_RPC_ERROR,
21                         APPLICATION_ERROR,
22                         SYSTEM_ERROR,
23                         TRANSPORT_ERROR,
24                 }
25                 [PrintfFormat]
26                 [CCode (cheader_filename = "libsoup/soup.h")]
27                 public static unowned string build_fault (int fault_code, string fault_format, ...);
28                 [CCode (cheader_filename = "libsoup/soup.h")]
29                 public static unowned string build_method_call (string method_name, GLib.Value[] @params);
30                 [CCode (cheader_filename = "libsoup/soup.h")]
31                 public static unowned string build_method_response (GLib.Value value);
32                 [CCode (cheader_filename = "libsoup/soup.h")]
33                 public static GLib.Quark error_quark ();
34                 [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
35                 public static bool extract_method_call (string method_call, int length, out unowned string method_name, ...);
36                 [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
37                 public static bool extract_method_response (string method_response, int length, ...) throws Soup.XMLRPC.Fault;
38                 [CCode (cheader_filename = "libsoup/soup.h")]
39                 public static GLib.Quark fault_quark ();
40                 [CCode (cheader_filename = "libsoup/soup.h")]
41                 public static bool parse_method_call (string method_call, int length, out unowned string method_name, out unowned GLib.ValueArray @params);
42                 [CCode (cheader_filename = "libsoup/soup.h")]
43                 public static bool parse_method_response (string method_response, int length, GLib.Value value) throws Soup.XMLRPC.Fault;
44                 [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
45                 public static unowned Soup.Message request_new (string uri, string method_name, ...);
46                 [PrintfFormat]
47                 [CCode (cheader_filename = "libsoup/soup.h")]
48                 public static void set_fault (Soup.Message msg, int fault_code, string fault_format, ...);
49                 [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
50                 public static void set_response (Soup.Message msg, ...);
51         }
52         [CCode (cheader_filename = "libsoup/soup.h")]
53         public class Address : GLib.Object {
54                 [CCode (has_construct_function = false)]
55                 public Address (string name, uint port);
56                 [CCode (has_construct_function = false)]
57                 public Address.any (Soup.AddressFamily family, uint port);
58                 public static bool equal_by_ip ([CCode (type = "void*")] Soup.Address addr1, [CCode (type = "void*")] Soup.Address addr2);
59                 public static bool equal_by_name ([CCode (type = "void*")] Soup.Address addr1, [CCode (type = "void*")] Soup.Address addr2);
60                 [CCode (has_construct_function = false)]
61                 public Address.from_sockaddr (void* sa, int len);
62                 public unowned string get_name ();
63                 public unowned string get_physical ();
64                 public uint get_port ();
65                 public void* get_sockaddr (int len);
66                 public static uint hash_by_ip (void* addr);
67                 public static uint hash_by_name (void* addr);
68                 public bool is_resolved ();
69                 public void resolve_async (GLib.MainContext async_context, GLib.Cancellable cancellable, Soup.AddressCallback callback);
70                 public uint resolve_sync (GLib.Cancellable cancellable);
71                 [NoAccessorMethod]
72                 public Soup.AddressFamily family { get; construct; }
73                 public string name { get; construct; }
74                 public string physical { get; }
75                 public int port { get; construct; }
76                 public void* sockaddr { get; construct; }
77         }
78         [CCode (cheader_filename = "libsoup/soup.h")]
79         public class Auth : GLib.Object {
80                 [CCode (has_construct_function = false)]
81                 public Auth (GLib.Type type, Soup.Message msg, string auth_header);
82                 public virtual void authenticate (string username, string password);
83                 public virtual unowned string get_authorization (Soup.Message msg);
84                 public unowned string get_host ();
85                 public unowned string get_info ();
86                 public virtual GLib.SList<string> get_protection_space (Soup.URI source_uri);
87                 public unowned string get_realm ();
88                 public unowned string get_scheme_name ();
89                 public virtual bool update (Soup.Message msg, string auth_header);
90                 public string host { get; construct; }
91                 [NoAccessorMethod]
92                 public bool is_authenticated { get; }
93                 [NoAccessorMethod]
94                 public bool is_for_proxy { get; construct; }
95                 public string realm { get; construct; }
96                 public string scheme_name { get; }
97                 public virtual signal void save_password (string p0, string p1);
98         }
99         [CCode (cheader_filename = "libsoup/soup.h")]
100         public class AuthDomain : GLib.Object {
101                 [CCode (has_construct_function = false)]
102                 protected AuthDomain ();
103                 public virtual unowned string accepts (Soup.Message msg);
104                 public void add_path (string path);
105                 public virtual unowned string challenge (Soup.Message msg);
106                 public virtual bool check_password (Soup.Message msg, string username, string password);
107                 public bool covers (Soup.Message msg);
108                 public unowned string get_realm ();
109                 public void remove_path (string path);
110                 public void set_filter (owned Soup.AuthDomainFilter filter);
111                 public void set_generic_auth_callback (owned Soup.AuthDomainGenericAuthCallback auth_callback);
112                 public bool try_generic_auth_callback (Soup.Message msg, string username);
113                 [NoAccessorMethod]
114                 public void* filter { get; set; }
115                 [NoAccessorMethod]
116                 public void* filter_data { get; set; }
117                 [NoAccessorMethod]
118                 public void* generic_auth_callback { get; set; }
119                 [NoAccessorMethod]
120                 public void* generic_auth_data { get; set; }
121                 [NoAccessorMethod]
122                 public bool proxy { get; construct; }
123                 public string realm { get; construct; }
124         }
125         [CCode (cheader_filename = "libsoup/soup.h")]
126         public class AuthDomainBasic : Soup.AuthDomain {
127                 [CCode (type = "SoupAuthDomain*", has_construct_function = false)]
128                 public AuthDomainBasic (string optname1);
129                 public static void set_auth_callback (Soup.AuthDomain domain, owned Soup.AuthDomainBasicAuthCallback callback);
130                 [NoAccessorMethod]
131                 public void* auth_callback { get; set; }
132                 [NoAccessorMethod]
133                 public void* auth_data { get; set; }
134         }
135         [CCode (cheader_filename = "libsoup/soup.h")]
136         public class AuthDomainDigest : Soup.AuthDomain {
137                 [CCode (type = "SoupAuthDomain*", has_construct_function = false)]
138                 public AuthDomainDigest (string optname1);
139                 public static unowned string encode_password (string username, string realm, string password);
140                 public static void set_auth_callback (Soup.AuthDomain domain, owned Soup.AuthDomainDigestAuthCallback callback);
141                 [NoAccessorMethod]
142                 public void* auth_callback { get; set; }
143                 [NoAccessorMethod]
144                 public void* auth_data { get; set; }
145         }
146         [Compact]
147         [CCode (ref_function = "soup_buffer_copy", unref_function = "soup_buffer_free", type_id = "SOUP_TYPE_BUFFER", cheader_filename = "libsoup/soup.h")]
148         public class Buffer {
149                 [CCode (array_length_cname = "length", array_length_type = "size_t")]
150                 public uint8[] data;
151                 public size_t length;
152                 [CCode (has_construct_function = false)]
153                 public Buffer (Soup.MemoryUse use, [CCode (type = "void*", array_length_type = "gsize")] uint8[] data);
154                 public Soup.Buffer copy ();
155                 public void* get_owner ();
156                 [CCode (has_construct_function = false)]
157                 public Buffer.subbuffer (Soup.Buffer parent, size_t offset, size_t length);
158                 [CCode (has_construct_function = false)]
159                 public Buffer.with_owner ([CCode (type = "void*", array_length_type = "gsize")] uint8[] data, void* owner, GLib.DestroyNotify? owner_dnotify);
160         }
161         [Compact]
162         [CCode (type_id = "SOUP_TYPE_BYTE_ARRAY", cheader_filename = "libsoup/soup.h")]
163         public class ByteArray {
164         }
165         [Compact]
166         [CCode (type_id = "SOUP_TYPE_CLIENT_CONTEXT", cheader_filename = "libsoup/soup.h")]
167         public class ClientContext {
168                 public unowned Soup.Address get_address ();
169                 public unowned Soup.AuthDomain get_auth_domain ();
170                 public unowned string get_auth_user ();
171                 public unowned string get_host ();
172                 public unowned Soup.Socket get_socket ();
173         }
174         [CCode (cheader_filename = "libsoup/soup.h")]
175         public class ContentDecoder : GLib.Object, Soup.SessionFeature {
176                 [CCode (has_construct_function = false)]
177                 protected ContentDecoder ();
178         }
179         [CCode (cheader_filename = "libsoup/soup.h")]
180         public class ContentSniffer : GLib.Object, Soup.SessionFeature {
181                 [CCode (has_construct_function = false)]
182                 public ContentSniffer ();
183                 [NoWrapper]
184                 public virtual size_t get_buffer_size ();
185                 public virtual string sniff (Soup.Message msg, Soup.Buffer buffer, out GLib.HashTable<string,string>? @params);
186         }
187         [Compact]
188         [CCode (copy_function = "soup_cookie_copy", type_id = "SOUP_TYPE_COOKIE", cheader_filename = "libsoup/soup.h")]
189         public class Cookie {
190                 public weak string domain;
191                 public weak Soup.Date expires;
192                 public bool http_only;
193                 public weak string name;
194                 public weak string path;
195                 public bool secure;
196                 public weak string value;
197                 [CCode (has_construct_function = false)]
198                 public Cookie (string name, string value, string domain, string path, int max_age);
199                 public bool applies_to_uri (Soup.URI uri);
200                 public Soup.Cookie copy ();
201                 public bool domain_matches (string host);
202                 public bool equal (Soup.Cookie cookie2);
203                 public static unowned Soup.Cookie parse (string header, Soup.URI origin);
204                 public void set_domain (string domain);
205                 public void set_expires (Soup.Date expires);
206                 public void set_http_only (bool http_only);
207                 public void set_max_age (int max_age);
208                 public void set_name (string name);
209                 public void set_path (string path);
210                 public void set_secure (bool secure);
211                 public void set_value (string value);
212                 public unowned string to_cookie_header ();
213                 public unowned string to_set_cookie_header ();
214         }
215         [CCode (cheader_filename = "libsoup/soup.h")]
216         public class CookieJar : GLib.Object, Soup.SessionFeature {
217                 [CCode (has_construct_function = false)]
218                 public CookieJar ();
219                 public void add_cookie (Soup.Cookie cookie);
220                 public GLib.SList<Soup.Cookie> all_cookies ();
221                 public void delete_cookie (Soup.Cookie cookie);
222                 public Soup.CookieJarAcceptPolicy get_accept_policy ();
223                 public unowned string get_cookies (Soup.URI uri, bool for_http);
224                 public virtual void save ();
225                 public void set_accept_policy (Soup.CookieJarAcceptPolicy policy);
226                 public void set_cookie (Soup.URI uri, string cookie);
227                 public void set_cookie_with_first_party (Soup.URI uri, Soup.URI first_party, string cookie);
228                 public Soup.CookieJarAcceptPolicy accept_policy { get; set; }
229                 [NoAccessorMethod]
230                 public bool read_only { get; construct; }
231                 public virtual signal void changed (Soup.Cookie old_cookie, Soup.Cookie new_cookie);
232         }
233         [CCode (cheader_filename = "libsoup/soup.h")]
234         public class CookieJarText : Soup.CookieJar, Soup.SessionFeature {
235                 [CCode (type = "SoupCookieJar*", has_construct_function = false)]
236                 public CookieJarText (string filename, bool read_only);
237                 [NoAccessorMethod]
238                 public string filename { owned get; construct; }
239         }
240         [Compact]
241         [CCode (copy_function = "soup_date_copy", type_id = "SOUP_TYPE_DATE", cheader_filename = "libsoup/soup.h")]
242         public class Date {
243                 public int day;
244                 public int hour;
245                 public int minute;
246                 public int month;
247                 public int offset;
248                 public int second;
249                 public bool utc;
250                 public int year;
251                 [CCode (has_construct_function = false)]
252                 public Date (int year, int month, int day, int hour, int minute, int second);
253                 public Soup.Date copy ();
254                 [CCode (has_construct_function = false)]
255                 public Date.from_now (int offset_seconds);
256                 [CCode (has_construct_function = false)]
257                 public Date.from_string (string date_string);
258                 [CCode (has_construct_function = false)]
259                 public Date.from_time_t (ulong when);
260                 public bool is_past ();
261                 public unowned string to_string (Soup.DateFormat format);
262                 public ulong to_time_t ();
263                 public void to_timeval (GLib.TimeVal time);
264         }
265         [CCode (cheader_filename = "libsoup/soup.h")]
266         public class Logger : GLib.Object, Soup.SessionFeature {
267                 [CCode (has_construct_function = false)]
268                 public Logger (Soup.LoggerLogLevel level, int max_body_size);
269                 public void set_printer (owned Soup.LoggerPrinter printer);
270                 public void set_request_filter (owned Soup.LoggerFilter request_filter);
271                 public void set_response_filter (owned Soup.LoggerFilter response_filter);
272         }
273         [CCode (cheader_filename = "libsoup/soup.h")]
274         public class Message : GLib.Object {
275                 public weak Soup.MessageBody request_body;
276                 public weak Soup.MessageHeaders request_headers;
277                 public weak Soup.MessageBody response_body;
278                 public weak Soup.MessageHeaders response_headers;
279                 [CCode (has_construct_function = false)]
280                 public Message (string method, string uri_string);
281                 public uint add_header_handler (string @signal, string header, GLib.Callback callback);
282                 public uint add_status_code_handler (string @signal, uint status_code, GLib.Callback callback);
283                 public void disable_feature (GLib.Type feature_type);
284                 [CCode (has_construct_function = false)]
285                 public Message.from_uri (string method, Soup.URI uri);
286                 public unowned Soup.Address get_address ();
287                 public unowned Soup.URI get_first_party ();
288                 public Soup.MessageFlags get_flags ();
289                 public Soup.HTTPVersion get_http_version ();
290                 public unowned Soup.URI get_uri ();
291                 public bool is_keepalive ();
292                 public void set_chunk_allocator (owned Soup.ChunkAllocator allocator);
293                 public void set_first_party (...);
294                 public void set_flags (Soup.MessageFlags flags);
295                 public void set_http_version (Soup.HTTPVersion version);
296                 public void set_request (string content_type, Soup.MemoryUse req_use, [CCode (type = "const char*", array_length_type = "gsize")] uint8[] req_body);
297                 public void set_response (string content_type, Soup.MemoryUse resp_use, [CCode (type = "const char*", array_length_type = "gsize")] uint8[] resp_body);
298                 public void set_status (uint status_code);
299                 public void set_status_full (uint status_code, string reason_phrase);
300                 public void set_uri (Soup.URI uri);
301                 public Soup.URI first_party { get; set; }
302                 public Soup.MessageFlags flags { get; set; }
303                 public Soup.HTTPVersion http_version { get; set; }
304                 [NoAccessorMethod]
305                 public string method { owned get; set; }
306                 [NoAccessorMethod]
307                 public string reason_phrase { owned get; set; }
308                 [NoAccessorMethod]
309                 public bool server_side { get; construct; }
310                 [NoAccessorMethod]
311                 public uint status_code { get; set; }
312                 public Soup.URI uri { get; set; }
313                 [HasEmitter]
314                 public virtual signal void content_sniffed (string p0, GLib.HashTable p1);
315                 [HasEmitter]
316                 public virtual signal void finished ();
317                 [HasEmitter]
318                 public virtual signal void got_body ();
319                 [HasEmitter]
320                 public virtual signal void got_chunk (Soup.Buffer chunk);
321                 [HasEmitter]
322                 public virtual signal void got_headers ();
323                 [HasEmitter]
324                 public virtual signal void got_informational ();
325                 [HasEmitter]
326                 public virtual signal void restarted ();
327                 [HasEmitter]
328                 public virtual signal void wrote_body ();
329                 [HasEmitter]
330                 public virtual signal void wrote_body_data (Soup.Buffer p0);
331                 [HasEmitter]
332                 public virtual signal void wrote_chunk ();
333                 [HasEmitter]
334                 public virtual signal void wrote_headers ();
335                 [HasEmitter]
336                 public virtual signal void wrote_informational ();
337         }
338         [Compact]
339         [CCode (type_id = "SOUP_TYPE_MESSAGE_BODY", cheader_filename = "libsoup/soup.h")]
340         public class MessageBody {
341                 [CCode (array_length_cname = "length", array_length_type = "gint64")]
342                 public weak uint8[] data;
343                 public int64 length;
344                 [CCode (has_construct_function = false)]
345                 public MessageBody ();
346                 public void append (Soup.MemoryUse use, [CCode (type = "gconstpointer", array_length_type = "gsize")] uint8[] data);
347                 public void append_buffer (Soup.Buffer buffer);
348                 public void complete ();
349                 public Soup.Buffer flatten ();
350                 public bool get_accumulate ();
351                 public unowned Soup.Buffer get_chunk (int64 offset);
352                 public void got_chunk (Soup.Buffer chunk);
353                 public void set_accumulate (bool accumulate);
354                 public void truncate ();
355                 public void wrote_chunk (Soup.Buffer chunk);
356         }
357         [Compact]
358         [CCode (type_id = "SOUP_TYPE_MESSAGE_HEADERS", cheader_filename = "libsoup/soup.h")]
359         public class MessageHeaders {
360                 [CCode (has_construct_function = false)]
361                 public MessageHeaders (Soup.MessageHeadersType type);
362                 public void append (string name, string value);
363                 public void clear ();
364                 public void @foreach (Soup.MessageHeadersForeachFunc func);
365                 public void free_ranges (Soup.Range ranges);
366                 public unowned string @get (string name);
367                 public bool get_content_disposition (out string disposition, out GLib.HashTable? @params);
368                 public int64 get_content_length ();
369                 public bool get_content_range (int64 start, int64 end, int64 total_length);
370                 public unowned string get_content_type (out GLib.HashTable<string,string>? @params);
371                 public Soup.Encoding get_encoding ();
372                 public Soup.Expectation get_expectations ();
373                 public unowned string get_list (string name);
374                 public unowned string get_one (string name);
375                 public bool get_ranges (int64 total_length, out unowned Soup.Range ranges, int length);
376                 public void remove (string name);
377                 public void replace (string name, string value);
378                 public void set_content_disposition (string disposition, GLib.HashTable<string,string>? @params);
379                 public void set_content_length (int64 content_length);
380                 public void set_content_range (int64 start, int64 end, int64 total_length);
381                 public void set_content_type (string content_type, GLib.HashTable<string,string>? @params);
382                 public void set_encoding (Soup.Encoding encoding);
383                 public void set_expectations (Soup.Expectation expectations);
384                 public void set_range (int64 start, int64 end);
385                 public void set_ranges (Soup.Range ranges, int length);
386         }
387         [Compact]
388         [CCode (cheader_filename = "libsoup/soup.h")]
389         public class MessageHeadersIter {
390                 public void init (Soup.MessageHeaders hdrs);
391                 public bool next (out unowned string name, out unowned string value);
392         }
393         [Compact]
394         [CCode (type_id = "SOUP_TYPE_MULTIPART", cheader_filename = "libsoup/soup.h")]
395         public class Multipart {
396                 [CCode (has_construct_function = false)]
397                 public Multipart (string mime_type);
398                 public void append_form_file (string control_name, string filename, string content_type, Soup.Buffer body);
399                 public void append_form_string (string control_name, string data);
400                 public void append_part (Soup.MessageHeaders headers, Soup.Buffer body);
401                 [CCode (has_construct_function = false)]
402                 public Multipart.from_message (Soup.MessageHeaders headers, Soup.MessageBody body);
403                 public int get_length ();
404                 public bool get_part (int part, out unowned Soup.MessageHeaders headers, out unowned Soup.Buffer body);
405                 public void to_message (Soup.MessageHeaders dest_headers, Soup.MessageBody dest_body);
406         }
407         [Compact]
408         [CCode (cheader_filename = "libsoup/soup.h")]
409         public class Range {
410                 public int64 end;
411                 public int64 start;
412         }
413         [CCode (cheader_filename = "libsoup/soup.h")]
414         public class Server : GLib.Object {
415                 [CCode (has_construct_function = false)]
416                 public Server (string optname1, ...);
417                 public void add_auth_domain (Soup.AuthDomain auth_domain);
418                 public void add_handler (string path, owned Soup.ServerCallback callback);
419                 public unowned GLib.MainContext get_async_context ();
420                 public unowned Soup.Socket get_listener ();
421                 public uint get_port ();
422                 public bool is_https ();
423                 public void pause_message (Soup.Message msg);
424                 public void quit ();
425                 public void remove_auth_domain (Soup.AuthDomain auth_domain);
426                 public void remove_handler (string path);
427                 public void run ();
428                 public void run_async ();
429                 public void unpause_message (Soup.Message msg);
430                 public GLib.MainContext async_context { get; construct; }
431                 [NoAccessorMethod]
432                 public Soup.Address @interface { owned get; construct; }
433                 public uint port { get; construct; }
434                 [NoAccessorMethod]
435                 public bool raw_paths { get; construct; }
436                 [NoAccessorMethod]
437                 public string server_header { owned get; set construct; }
438                 [NoAccessorMethod]
439                 public string ssl_cert_file { owned get; construct; }
440                 [NoAccessorMethod]
441                 public string ssl_key_file { owned get; construct; }
442                 public virtual signal void request_aborted (Soup.Message msg, Soup.ClientContext client);
443                 public virtual signal void request_finished (Soup.Message msg, Soup.ClientContext client);
444                 public virtual signal void request_read (Soup.Message msg, Soup.ClientContext client);
445                 public virtual signal void request_started (Soup.Message msg, Soup.ClientContext client);
446         }
447         [CCode (cheader_filename = "libsoup/soup.h")]
448         public class Session : GLib.Object {
449                 [CCode (has_construct_function = false)]
450                 protected Session ();
451                 public void abort ();
452                 [NoWrapper]
453                 public virtual void auth_required (Soup.Message msg, Soup.Auth auth, bool retrying);
454                 public virtual void cancel_message (Soup.Message msg, uint status_code);
455                 public unowned GLib.MainContext get_async_context ();
456                 public unowned Soup.SessionFeature get_feature (GLib.Type feature_type);
457                 public unowned Soup.SessionFeature get_feature_for_message (GLib.Type feature_type, Soup.Message msg);
458                 public GLib.SList<weak Soup.SessionFeature> get_features (GLib.Type feature_type);
459                 public void pause_message (Soup.Message msg);
460                 public void prepare_for_uri (Soup.URI uri);
461                 public virtual void queue_message (owned Soup.Message msg, Soup.SessionCallback? callback);
462                 public void remove_feature (Soup.SessionFeature feature);
463                 public virtual void requeue_message (Soup.Message msg);
464                 public virtual uint send_message (Soup.Message msg);
465                 public void unpause_message (Soup.Message msg);
466                 [NoAccessorMethod]
467                 public string accept_language { owned get; set; }
468                 [NoAccessorMethod]
469                 public bool accept_language_auto { get; set; }
470                 [NoAccessorMethod]
471                 public Soup.SessionFeature add_feature { owned get; set; }
472                 [NoAccessorMethod]
473                 public GLib.Type add_feature_by_type { get; set; }
474                 public GLib.MainContext async_context { get; construct; }
475                 [NoAccessorMethod]
476                 public uint idle_timeout { get; set; }
477                 [NoAccessorMethod]
478                 public int max_conns { get; set; }
479                 [NoAccessorMethod]
480                 public int max_conns_per_host { get; set; }
481                 [NoAccessorMethod]
482                 public Soup.URI proxy_uri { owned get; set; }
483                 [NoAccessorMethod]
484                 public GLib.Type remove_feature_by_type { get; set; }
485                 [NoAccessorMethod]
486                 public string ssl_ca_file { owned get; set; }
487                 [NoAccessorMethod]
488                 public bool ssl_strict { get; set; }
489                 [NoAccessorMethod]
490                 public uint timeout { get; set; }
491                 [NoAccessorMethod]
492                 public bool use_ntlm { get; set; }
493                 [NoAccessorMethod]
494                 public string user_agent { owned get; set; }
495                 public virtual signal void authenticate (Soup.Message msg, Soup.Auth auth, bool retrying);
496                 public virtual signal void connection_created (GLib.Object p0);
497                 public virtual signal void request_queued (Soup.Message p0);
498                 public virtual signal void request_started (Soup.Message msg, Soup.Socket socket);
499                 public virtual signal void request_unqueued (Soup.Message p0);
500                 public virtual signal void tunneling (GLib.Object p0);
501         }
502         [CCode (cheader_filename = "libsoup/soup.h")]
503         public class SessionAsync : Soup.Session {
504                 [CCode (type = "SoupSession*", has_construct_function = false)]
505                 public SessionAsync ();
506                 [CCode (type = "SoupSession*", has_construct_function = false)]
507                 public SessionAsync.with_options (string optname1, ...);
508         }
509         [CCode (cheader_filename = "libsoup/soup.h")]
510         public class SessionSync : Soup.Session {
511                 [CCode (type = "SoupSession*", has_construct_function = false)]
512                 public SessionSync ();
513                 [CCode (type = "SoupSession*", has_construct_function = false)]
514                 public SessionSync.with_options (string optname1, ...);
515         }
516         [CCode (cheader_filename = "libsoup/soup.h")]
517         public class Socket : GLib.Object {
518                 [CCode (has_construct_function = false)]
519                 public Socket (string optname1);
520                 public void connect_async (GLib.Cancellable cancellable, Soup.SocketCallback callback);
521                 public uint connect_sync (GLib.Cancellable cancellable);
522                 public void disconnect ();
523                 public int get_fd ();
524                 public unowned Soup.Address get_local_address ();
525                 public unowned Soup.Address get_remote_address ();
526                 public bool is_connected ();
527                 public bool is_ssl ();
528                 public bool listen ();
529                 public Soup.SocketIOStatus read ([CCode (array_length_type = "gsize")] uint8[] buffer, out size_t nread, GLib.Cancellable? cancellable = null) throws GLib.Error;
530                 public Soup.SocketIOStatus read_until ([CCode (array_length_type = "gsize")] uint8[] buffer, [CCode (array_length_type = "gsize")] uint8[] boundary, out size_t nread, out bool got_boundary, GLib.Cancellable? cancellable = null) throws GLib.Error;
531                 public bool start_proxy_ssl (string ssl_host, GLib.Cancellable cancellable);
532                 public bool start_ssl (GLib.Cancellable cancellable);
533                 public Soup.SocketIOStatus write ([CCode (array_length_type = "gsize")] uint8[] buffer, out size_t nwrote, GLib.Cancellable? cancellable = null) throws GLib.Error;
534                 [NoAccessorMethod]
535                 public GLib.MainContext async_context { get; construct; }
536                 [NoAccessorMethod]
537                 public bool is_server { get; }
538                 public Soup.Address local_address { get; construct; }
539                 [NoAccessorMethod]
540                 public bool non_blocking { get; set; }
541                 public Soup.Address remote_address { get; construct; }
542                 [NoAccessorMethod]
543                 public void* ssl_creds { get; set; }
544                 [NoAccessorMethod]
545                 public bool ssl_strict { get; construct; }
546                 [NoAccessorMethod]
547                 public uint timeout { get; set; }
548                 [NoAccessorMethod]
549                 public bool trusted_certificate { get; construct; }
550                 public virtual signal void disconnected ();
551                 public virtual signal void new_connection (Soup.Socket p0);
552                 public virtual signal void readable ();
553                 public virtual signal void writable ();
554         }
555         [Compact]
556         [CCode (copy_function = "soup_uri_copy", type_id = "SOUP_TYPE_URI", cheader_filename = "libsoup/soup.h")]
557         public class URI {
558                 public weak string fragment;
559                 public weak string host;
560                 public weak string password;
561                 public weak string path;
562                 public uint port;
563                 public weak string query;
564                 public weak string scheme;
565                 public weak string user;
566                 [CCode (has_construct_function = false)]
567                 public URI (string uri_string);
568                 public Soup.URI copy ();
569                 public unowned Soup.URI copy_host ();
570                 public static string decode (string part);
571                 public static string encode (string part, string? escape_extra);
572                 public bool equal (Soup.URI uri2);
573                 public static bool host_equal (Soup.URI v1, Soup.URI v2);
574                 public static uint host_hash (Soup.URI key);
575                 public static string normalize (string part, string unescape_extra);
576                 public void set_fragment (string fragment);
577                 public void set_host (string host);
578                 public void set_password (string password);
579                 public void set_path (string path);
580                 public void set_port (uint port);
581                 public void set_query (string query);
582                 public void set_query_from_fields (...);
583                 public void set_query_from_form (GLib.HashTable<string,string> form);
584                 public void set_scheme (string scheme);
585                 public void set_user (string user);
586                 public string to_string (bool just_path_and_query);
587                 public bool uses_default_port ();
588                 [CCode (has_construct_function = false)]
589                 public URI.with_base (Soup.URI @base, string uri_string);
590         }
591         [CCode (cheader_filename = "libsoup/soup.h")]
592         public interface ProxyResolver : Soup.SessionFeature, GLib.Object {
593                 public abstract void get_proxy_async (Soup.Message msg, GLib.MainContext async_context, GLib.Cancellable cancellable, Soup.ProxyResolverCallback callback);
594                 public abstract uint get_proxy_sync (Soup.Message msg, GLib.Cancellable cancellable, out unowned Soup.Address addr);
595         }
596         [CCode (cheader_filename = "libsoup/soup.h")]
597         public interface ProxyURIResolver : GLib.Object {
598                 public abstract void get_proxy_uri_async (Soup.URI uri, GLib.MainContext async_context, GLib.Cancellable cancellable, Soup.ProxyURIResolverCallback callback);
599                 public abstract uint get_proxy_uri_sync (Soup.URI uri, GLib.Cancellable cancellable, out unowned Soup.URI proxy_uri);
600         }
601         [CCode (cheader_filename = "libsoup/soup.h")]
602         public interface SessionFeature : GLib.Object {
603                 public abstract void attach (Soup.Session session);
604                 public abstract void detach (Soup.Session session);
605                 [NoWrapper]
606                 public abstract void request_queued (Soup.Session session, Soup.Message msg);
607                 [NoWrapper]
608                 public abstract void request_started (Soup.Session session, Soup.Message msg, Soup.Socket socket);
609                 [NoWrapper]
610                 public abstract void request_unqueued (Soup.Session session, Soup.Message msg);
611         }
612         [CCode (cprefix = "SOUP_ADDRESS_FAMILY_", cheader_filename = "libsoup/soup.h")]
613         public enum AddressFamily {
614                 INVALID,
615                 IPV4,
616                 IPV6
617         }
618         [CCode (cprefix = "SOUP_CONNECTION_", cheader_filename = "libsoup/soup.h")]
619         public enum ConnectionState {
620                 NEW,
621                 CONNECTING,
622                 IDLE,
623                 IN_USE,
624                 REMOTE_DISCONNECTED,
625                 DISCONNECTED
626         }
627         [CCode (cprefix = "SOUP_COOKIE_JAR_ACCEPT_", cheader_filename = "libsoup/soup.h")]
628         public enum CookieJarAcceptPolicy {
629                 ALWAYS,
630                 NEVER,
631                 NO_THIRD_PARTY
632         }
633         [CCode (cprefix = "SOUP_DATE_", cheader_filename = "libsoup/soup.h")]
634         public enum DateFormat {
635                 HTTP,
636                 COOKIE,
637                 RFC2822,
638                 ISO8601_COMPACT,
639                 ISO8601_FULL,
640                 ISO8601,
641                 ISO8601_XMLRPC
642         }
643         [CCode (cprefix = "SOUP_ENCODING_", cheader_filename = "libsoup/soup.h")]
644         public enum Encoding {
645                 UNRECOGNIZED,
646                 NONE,
647                 CONTENT_LENGTH,
648                 EOF,
649                 CHUNKED,
650                 BYTERANGES
651         }
652         [CCode (cprefix = "SOUP_EXPECTATION_", cheader_filename = "libsoup/soup.h")]
653         [Flags]
654         public enum Expectation {
655                 UNRECOGNIZED,
656                 CONTINUE
657         }
658         [CCode (cprefix = "SOUP_HTTP_", cheader_filename = "libsoup/soup.h")]
659         public enum HTTPVersion {
660                 @1_0,
661                 @1_1
662         }
663         [CCode (cprefix = "SOUP_STATUS_", cheader_filename = "libsoup/soup.h")]
664         public enum KnownStatusCode {
665                 NONE,
666                 CANCELLED,
667                 CANT_RESOLVE,
668                 CANT_RESOLVE_PROXY,
669                 CANT_CONNECT,
670                 CANT_CONNECT_PROXY,
671                 SSL_FAILED,
672                 IO_ERROR,
673                 MALFORMED,
674                 TRY_AGAIN,
675                 TOO_MANY_REDIRECTS,
676                 CONTINUE,
677                 SWITCHING_PROTOCOLS,
678                 PROCESSING,
679                 OK,
680                 CREATED,
681                 ACCEPTED,
682                 NON_AUTHORITATIVE,
683                 NO_CONTENT,
684                 RESET_CONTENT,
685                 PARTIAL_CONTENT,
686                 MULTI_STATUS,
687                 MULTIPLE_CHOICES,
688                 MOVED_PERMANENTLY,
689                 FOUND,
690                 MOVED_TEMPORARILY,
691                 SEE_OTHER,
692                 NOT_MODIFIED,
693                 USE_PROXY,
694                 NOT_APPEARING_IN_THIS_PROTOCOL,
695                 TEMPORARY_REDIRECT,
696                 BAD_REQUEST,
697                 UNAUTHORIZED,
698                 PAYMENT_REQUIRED,
699                 FORBIDDEN,
700                 NOT_FOUND,
701                 METHOD_NOT_ALLOWED,
702                 NOT_ACCEPTABLE,
703                 PROXY_AUTHENTICATION_REQUIRED,
704                 PROXY_UNAUTHORIZED,
705                 REQUEST_TIMEOUT,
706                 CONFLICT,
707                 GONE,
708                 LENGTH_REQUIRED,
709                 PRECONDITION_FAILED,
710                 REQUEST_ENTITY_TOO_LARGE,
711                 REQUEST_URI_TOO_LONG,
712                 UNSUPPORTED_MEDIA_TYPE,
713                 REQUESTED_RANGE_NOT_SATISFIABLE,
714                 INVALID_RANGE,
715                 EXPECTATION_FAILED,
716                 UNPROCESSABLE_ENTITY,
717                 LOCKED,
718                 FAILED_DEPENDENCY,
719                 INTERNAL_SERVER_ERROR,
720                 NOT_IMPLEMENTED,
721                 BAD_GATEWAY,
722                 SERVICE_UNAVAILABLE,
723                 GATEWAY_TIMEOUT,
724                 HTTP_VERSION_NOT_SUPPORTED,
725                 INSUFFICIENT_STORAGE,
726                 NOT_EXTENDED
727         }
728         [CCode (cprefix = "SOUP_LOGGER_LOG_", cheader_filename = "libsoup/soup.h")]
729         public enum LoggerLogLevel {
730                 NONE,
731                 MINIMAL,
732                 HEADERS,
733                 BODY
734         }
735         [CCode (cprefix = "SOUP_MEMORY_", cheader_filename = "libsoup/soup.h")]
736         public enum MemoryUse {
737                 STATIC,
738                 TAKE,
739                 COPY,
740                 TEMPORARY
741         }
742         [CCode (cprefix = "SOUP_MESSAGE_", cheader_filename = "libsoup/soup.h")]
743         [Flags]
744         public enum MessageFlags {
745                 NO_REDIRECT,
746                 OVERWRITE_CHUNKS,
747                 CONTENT_DECODED,
748                 CERTIFICATE_TRUSTED
749         }
750         [CCode (cprefix = "SOUP_MESSAGE_HEADERS_", cheader_filename = "libsoup/soup.h")]
751         public enum MessageHeadersType {
752                 REQUEST,
753                 RESPONSE,
754                 MULTIPART
755         }
756         [CCode (cprefix = "SOUP_SSL_ERROR_", cheader_filename = "libsoup/soup.h")]
757         public enum SSLError {
758                 HANDSHAKE_NEEDS_READ,
759                 HANDSHAKE_NEEDS_WRITE,
760                 CERTIFICATE,
761                 HANDSHAKE_FAILED
762         }
763         [CCode (cprefix = "SOUP_SOCKET_", cheader_filename = "libsoup/soup.h")]
764         public enum SocketIOStatus {
765                 OK,
766                 WOULD_BLOCK,
767                 EOF,
768                 ERROR
769         }
770         [CCode (cheader_filename = "libsoup/soup.h")]
771         public delegate void AddressCallback (Soup.Address addr, uint status);
772         [CCode (cheader_filename = "libsoup/soup.h")]
773         public delegate bool AuthDomainBasicAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username, string password);
774         [CCode (cheader_filename = "libsoup/soup.h")]
775         public delegate unowned string AuthDomainDigestAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username);
776         [CCode (cheader_filename = "libsoup/soup.h")]
777         public delegate bool AuthDomainFilter (Soup.AuthDomain domain, Soup.Message msg);
778         [CCode (cheader_filename = "libsoup/soup.h")]
779         public delegate bool AuthDomainGenericAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username);
780         [CCode (cheader_filename = "libsoup/soup.h")]
781         public delegate unowned Soup.Buffer ChunkAllocator (Soup.Message msg, size_t max_len);
782         [CCode (cheader_filename = "libsoup/soup.h")]
783         public delegate Soup.LoggerLogLevel LoggerFilter (Soup.Logger logger, Soup.Message msg);
784         [CCode (cheader_filename = "libsoup/soup.h")]
785         public delegate void LoggerPrinter (Soup.Logger logger, Soup.LoggerLogLevel level, char direction, string data);
786         [CCode (cheader_filename = "libsoup/soup.h")]
787         public delegate void MessageHeadersForeachFunc (string name, string value);
788         [CCode (cheader_filename = "libsoup/soup.h")]
789         public delegate void ProxyResolverCallback (Soup.ProxyResolver p1, Soup.Message p2, uint p3, Soup.Address p4);
790         [CCode (cheader_filename = "libsoup/soup.h")]
791         public delegate void ProxyURIResolverCallback (Soup.ProxyURIResolver resolver, uint status, Soup.URI proxy_uri);
792         [CCode (cheader_filename = "libsoup/soup.h")]
793         public delegate void ServerCallback (Soup.Server server, Soup.Message msg, string path, GLib.HashTable<string,string> query, Soup.ClientContext client);
794         [CCode (cheader_filename = "libsoup/soup.h")]
795         public delegate void SessionCallback (Soup.Session session, Soup.Message msg);
796         [CCode (cheader_filename = "libsoup/soup.h")]
797         public delegate void SocketCallback (Soup.Socket sock, uint status);
798         [CCode (cheader_filename = "libsoup/soup.h")]
799         public const int ADDRESS_ANY_PORT;
800         [CCode (cheader_filename = "libsoup/soup.h")]
801         public const string ADDRESS_FAMILY;
802         [CCode (cheader_filename = "libsoup/soup.h")]
803         public const string ADDRESS_NAME;
804         [CCode (cheader_filename = "libsoup/soup.h")]
805         public const string ADDRESS_PHYSICAL;
806         [CCode (cheader_filename = "libsoup/soup.h")]
807         public const string ADDRESS_PORT;
808         [CCode (cheader_filename = "libsoup/soup.h")]
809         public const string ADDRESS_SOCKADDR;
810         [CCode (cheader_filename = "libsoup/soup.h")]
811         public const string AUTH_DOMAIN_ADD_PATH;
812         [CCode (cheader_filename = "libsoup/soup.h")]
813         public const string AUTH_DOMAIN_BASIC_AUTH_CALLBACK;
814         [CCode (cheader_filename = "libsoup/soup.h")]
815         public const string AUTH_DOMAIN_BASIC_AUTH_DATA;
816         [CCode (cheader_filename = "libsoup/soup.h")]
817         public const int AUTH_DOMAIN_BASIC_H;
818         [CCode (cheader_filename = "libsoup/soup.h")]
819         public const string AUTH_DOMAIN_DIGEST_AUTH_CALLBACK;
820         [CCode (cheader_filename = "libsoup/soup.h")]
821         public const string AUTH_DOMAIN_DIGEST_AUTH_DATA;
822         [CCode (cheader_filename = "libsoup/soup.h")]
823         public const int AUTH_DOMAIN_DIGEST_H;
824         [CCode (cheader_filename = "libsoup/soup.h")]
825         public const string AUTH_DOMAIN_FILTER;
826         [CCode (cheader_filename = "libsoup/soup.h")]
827         public const string AUTH_DOMAIN_FILTER_DATA;
828         [CCode (cheader_filename = "libsoup/soup.h")]
829         public const string AUTH_DOMAIN_GENERIC_AUTH_CALLBACK;
830         [CCode (cheader_filename = "libsoup/soup.h")]
831         public const string AUTH_DOMAIN_GENERIC_AUTH_DATA;
832         [CCode (cheader_filename = "libsoup/soup.h")]
833         public const int AUTH_DOMAIN_H;
834         [CCode (cheader_filename = "libsoup/soup.h")]
835         public const string AUTH_DOMAIN_PROXY;
836         [CCode (cheader_filename = "libsoup/soup.h")]
837         public const string AUTH_DOMAIN_REALM;
838         [CCode (cheader_filename = "libsoup/soup.h")]
839         public const string AUTH_DOMAIN_REMOVE_PATH;
840         [CCode (cheader_filename = "libsoup/soup.h")]
841         public const int AUTH_H;
842         [CCode (cheader_filename = "libsoup/soup.h")]
843         public const string AUTH_HOST;
844         [CCode (cheader_filename = "libsoup/soup.h")]
845         public const string AUTH_IS_AUTHENTICATED;
846         [CCode (cheader_filename = "libsoup/soup.h")]
847         public const string AUTH_IS_FOR_PROXY;
848         [CCode (cheader_filename = "libsoup/soup.h")]
849         public const string AUTH_REALM;
850         [CCode (cheader_filename = "libsoup/soup.h")]
851         public const string AUTH_SCHEME_NAME;
852         [CCode (cheader_filename = "libsoup/soup.h")]
853         public const int CHAR_HTTP_CTL;
854         [CCode (cheader_filename = "libsoup/soup.h")]
855         public const int CHAR_HTTP_SEPARATOR;
856         [CCode (cheader_filename = "libsoup/soup.h")]
857         public const int CHAR_URI_GEN_DELIMS;
858         [CCode (cheader_filename = "libsoup/soup.h")]
859         public const int CHAR_URI_PERCENT_ENCODED;
860         [CCode (cheader_filename = "libsoup/soup.h")]
861         public const int CHAR_URI_SUB_DELIMS;
862         [CCode (cheader_filename = "libsoup/soup.h")]
863         public const int CONTENT_DECODER_H;
864         [CCode (cheader_filename = "libsoup/soup.h")]
865         public const int CONTENT_SNIFFER_H;
866         [CCode (cheader_filename = "libsoup/soup.h")]
867         public const int COOKIE_H;
868         [CCode (cheader_filename = "libsoup/soup.h")]
869         public const string COOKIE_JAR_ACCEPT_POLICY;
870         [CCode (cheader_filename = "libsoup/soup.h")]
871         public const int COOKIE_JAR_H;
872         [CCode (cheader_filename = "libsoup/soup.h")]
873         public const string COOKIE_JAR_READ_ONLY;
874         [CCode (cheader_filename = "libsoup/soup.h")]
875         public const string COOKIE_JAR_TEXT_FILENAME;
876         [CCode (cheader_filename = "libsoup/soup.h")]
877         public const int COOKIE_JAR_TEXT_H;
878         [CCode (cheader_filename = "libsoup/soup.h")]
879         public const int COOKIE_MAX_AGE_ONE_DAY;
880         [CCode (cheader_filename = "libsoup/soup.h")]
881         public const int COOKIE_MAX_AGE_ONE_HOUR;
882         [CCode (cheader_filename = "libsoup/soup.h")]
883         public const int COOKIE_MAX_AGE_ONE_WEEK;
884         [CCode (cheader_filename = "libsoup/soup.h")]
885         public const int COOKIE_MAX_AGE_ONE_YEAR;
886         [CCode (cheader_filename = "libsoup/soup.h")]
887         public const int DATE_H;
888         [CCode (cheader_filename = "libsoup/soup.h")]
889         public const int FORM_H;
890         [CCode (cheader_filename = "libsoup/soup.h")]
891         public const string FORM_MIME_TYPE_MULTIPART;
892         [CCode (cheader_filename = "libsoup/soup.h")]
893         public const string FORM_MIME_TYPE_URLENCODED;
894         [CCode (cheader_filename = "libsoup/soup.h")]
895         public const int H;
896         [CCode (cheader_filename = "libsoup/soup.h")]
897         public const int HEADERS_H;
898         [CCode (cheader_filename = "libsoup/soup.h")]
899         public const int LOGGER_H;
900         [CCode (cheader_filename = "libsoup/soup.h")]
901         public const int MESSAGE_BODY_H;
902         [CCode (cheader_filename = "libsoup/soup.h")]
903         public const string MESSAGE_FIRST_PARTY;
904         [CCode (cheader_filename = "libsoup/soup.h")]
905         public const string MESSAGE_FLAGS;
906         [CCode (cheader_filename = "libsoup/soup.h")]
907         public const int MESSAGE_H;
908         [CCode (cheader_filename = "libsoup/soup.h")]
909         public const int MESSAGE_HEADERS_H;
910         [CCode (cheader_filename = "libsoup/soup.h")]
911         public const string MESSAGE_HTTP_VERSION;
912         [CCode (cheader_filename = "libsoup/soup.h")]
913         public const string MESSAGE_METHOD;
914         [CCode (cheader_filename = "libsoup/soup.h")]
915         public const string MESSAGE_REASON_PHRASE;
916         [CCode (cheader_filename = "libsoup/soup.h")]
917         public const string MESSAGE_SERVER_SIDE;
918         [CCode (cheader_filename = "libsoup/soup.h")]
919         public const string MESSAGE_STATUS_CODE;
920         [CCode (cheader_filename = "libsoup/soup.h")]
921         public const string MESSAGE_URI;
922         [CCode (cheader_filename = "libsoup/soup.h")]
923         public const int METHOD_H;
924         [CCode (cheader_filename = "libsoup/soup.h")]
925         public const int MISC_H;
926         [CCode (cheader_filename = "libsoup/soup.h")]
927         public const int MULTIPART_H;
928         [CCode (cheader_filename = "libsoup/soup.h")]
929         public const int PASSWORD_MANAGER_H;
930         [CCode (cheader_filename = "libsoup/soup.h")]
931         public const int PROXY_RESOLVER_H;
932         [CCode (cheader_filename = "libsoup/soup.h")]
933         public const int PROXY_URI_RESOLVER_H;
934         [CCode (cheader_filename = "libsoup/soup.h")]
935         public const string SERVER_ASYNC_CONTEXT;
936         [CCode (cheader_filename = "libsoup/soup.h")]
937         public const int SERVER_H;
938         [CCode (cheader_filename = "libsoup/soup.h")]
939         public const string SERVER_INTERFACE;
940         [CCode (cheader_filename = "libsoup/soup.h")]
941         public const string SERVER_PORT;
942         [CCode (cheader_filename = "libsoup/soup.h")]
943         public const string SERVER_RAW_PATHS;
944         [CCode (cheader_filename = "libsoup/soup.h")]
945         public const string SERVER_SERVER_HEADER;
946         [CCode (cheader_filename = "libsoup/soup.h")]
947         public const string SERVER_SSL_CERT_FILE;
948         [CCode (cheader_filename = "libsoup/soup.h")]
949         public const string SERVER_SSL_KEY_FILE;
950         [CCode (cheader_filename = "libsoup/soup.h")]
951         public const string SESSION_ACCEPT_LANGUAGE;
952         [CCode (cheader_filename = "libsoup/soup.h")]
953         public const string SESSION_ACCEPT_LANGUAGE_AUTO;
954         [CCode (cheader_filename = "libsoup/soup.h")]
955         public const string SESSION_ADD_FEATURE;
956         [CCode (cheader_filename = "libsoup/soup.h")]
957         public const string SESSION_ADD_FEATURE_BY_TYPE;
958         [CCode (cheader_filename = "libsoup/soup.h")]
959         public const string SESSION_ASYNC_CONTEXT;
960         [CCode (cheader_filename = "libsoup/soup.h")]
961         public const int SESSION_ASYNC_H;
962         [CCode (cheader_filename = "libsoup/soup.h")]
963         public const int SESSION_FEATURE_H;
964         [CCode (cheader_filename = "libsoup/soup.h")]
965         public const int SESSION_H;
966         [CCode (cheader_filename = "libsoup/soup.h")]
967         public const string SESSION_IDLE_TIMEOUT;
968         [CCode (cheader_filename = "libsoup/soup.h")]
969         public const string SESSION_MAX_CONNS;
970         [CCode (cheader_filename = "libsoup/soup.h")]
971         public const string SESSION_MAX_CONNS_PER_HOST;
972         [CCode (cheader_filename = "libsoup/soup.h")]
973         public const string SESSION_PROXY_URI;
974         [CCode (cheader_filename = "libsoup/soup.h")]
975         public const string SESSION_REMOVE_FEATURE_BY_TYPE;
976         [CCode (cheader_filename = "libsoup/soup.h")]
977         public const string SESSION_SSL_CA_FILE;
978         [CCode (cheader_filename = "libsoup/soup.h")]
979         public const string SESSION_SSL_STRICT;
980         [CCode (cheader_filename = "libsoup/soup.h")]
981         public const int SESSION_SYNC_H;
982         [CCode (cheader_filename = "libsoup/soup.h")]
983         public const string SESSION_TIMEOUT;
984         [CCode (cheader_filename = "libsoup/soup.h")]
985         public const string SESSION_USER_AGENT;
986         [CCode (cheader_filename = "libsoup/soup.h")]
987         public const string SESSION_USE_NTLM;
988         [CCode (cheader_filename = "libsoup/soup.h")]
989         public const string SOCKET_ASYNC_CONTEXT;
990         [CCode (cheader_filename = "libsoup/soup.h")]
991         public const string SOCKET_FLAG_NONBLOCKING;
992         [CCode (cheader_filename = "libsoup/soup.h")]
993         public const int SOCKET_H;
994         [CCode (cheader_filename = "libsoup/soup.h")]
995         public const string SOCKET_IS_SERVER;
996         [CCode (cheader_filename = "libsoup/soup.h")]
997         public const string SOCKET_LOCAL_ADDRESS;
998         [CCode (cheader_filename = "libsoup/soup.h")]
999         public const string SOCKET_REMOTE_ADDRESS;
1000         [CCode (cheader_filename = "libsoup/soup.h")]
1001         public const string SOCKET_SSL_CREDENTIALS;
1002         [CCode (cheader_filename = "libsoup/soup.h")]
1003         public const string SOCKET_SSL_STRICT;
1004         [CCode (cheader_filename = "libsoup/soup.h")]
1005         public const string SOCKET_TIMEOUT;
1006         [CCode (cheader_filename = "libsoup/soup.h")]
1007         public const string SOCKET_TRUSTED_CERTIFICATE;
1008         [CCode (cheader_filename = "libsoup/soup.h")]
1009         public const int STATUS_H;
1010         [CCode (cheader_filename = "libsoup/soup.h")]
1011         public const int TYPES_H;
1012         [CCode (cheader_filename = "libsoup/soup.h")]
1013         public const int URI_H;
1014         [CCode (cheader_filename = "libsoup/soup.h")]
1015         public const int VALUE_UTILS_H;
1016         [CCode (cheader_filename = "libsoup/soup.h")]
1017         public const int XMLRPC_H;
1018         [CCode (cheader_filename = "libsoup/soup.h")]
1019         public static unowned GLib.TimeoutSource add_completion (GLib.MainContext async_context, GLib.SourceFunc function, void* data);
1020         [CCode (cheader_filename = "libsoup/soup.h")]
1021         public static unowned GLib.TimeoutSource add_idle (GLib.MainContext async_context, GLib.SourceFunc function, void* data);
1022         [CCode (cheader_filename = "libsoup/soup.h")]
1023         public static unowned GLib.TimeoutSource add_timeout (GLib.MainContext async_context, uint interval, GLib.SourceFunc function, void* data);
1024         [CCode (cheader_filename = "libsoup/soup.h")]
1025         public static GLib.SList<Soup.Cookie> cookies_from_request (Soup.Message msg);
1026         [CCode (cheader_filename = "libsoup/soup.h")]
1027         public static GLib.SList<Soup.Cookie> cookies_from_response (Soup.Message msg);
1028         [CCode (cheader_filename = "libsoup/soup.h")]
1029         public static unowned string cookies_to_cookie_header (GLib.SList<Soup.Cookie> cookies);
1030         [CCode (cheader_filename = "libsoup/soup.h")]
1031         public static void cookies_to_request (GLib.SList<Soup.Cookie> cookies, Soup.Message msg);
1032         [CCode (cheader_filename = "libsoup/soup.h")]
1033         public static void cookies_to_response (GLib.SList<Soup.Cookie> cookies, Soup.Message msg);
1034         [CCode (cheader_filename = "libsoup/soup.h")]
1035         public static GLib.HashTable<string,string> form_decode (string encoded_form);
1036         [CCode (cheader_filename = "libsoup/soup.h")]
1037         public static GLib.HashTable<string,string> form_decode_multipart (Soup.Message msg, string file_control_name, out string filename, out string content_type, out Soup.Buffer file);
1038         [CCode (cheader_filename = "libsoup/soup.h")]
1039         public static unowned string form_encode (...);
1040         [CCode (cheader_filename = "libsoup/soup.h")]
1041         public static unowned string form_encode_datalist (void* form_data_set);
1042         [CCode (cheader_filename = "libsoup/soup.h")]
1043         public static unowned string form_encode_hash (GLib.HashTable<string,string> form_data_set);
1044         [CCode (cheader_filename = "libsoup/soup.h")]
1045         public static unowned string form_encode_valist (string first_field, void* args);
1046         [CCode (cheader_filename = "libsoup/soup.h")]
1047         public static unowned Soup.Message form_request_new (string method, string uri, ...);
1048         [CCode (cheader_filename = "libsoup/soup.h")]
1049         public static unowned Soup.Message form_request_new_from_datalist (string method, string uri, void* form_data_set);
1050         [CCode (cheader_filename = "libsoup/soup.h")]
1051         public static unowned Soup.Message form_request_new_from_hash (string method, string uri, GLib.HashTable<string,string> form_data_set);
1052         [CCode (cheader_filename = "libsoup/soup.h")]
1053         public static unowned Soup.Message form_request_new_from_multipart (string uri, Soup.Multipart multipart);
1054         [CCode (cheader_filename = "libsoup/soup.h")]
1055         public static bool header_contains (string header, string token);
1056         [CCode (cheader_filename = "libsoup/soup.h")]
1057         public static void header_g_string_append_param (GLib.StringBuilder str, string name, string value);
1058         [CCode (cheader_filename = "libsoup/soup.h")]
1059         public static void header_g_string_append_param_quoted (GLib.StringBuilder str, string name, string value);
1060         [CCode (cheader_filename = "libsoup/soup.h")]
1061         public static GLib.SList<string> header_parse_list (string header);
1062         [CCode (cheader_filename = "libsoup/soup.h")]
1063         public static GLib.HashTable<string,string> header_parse_param_list (string header);
1064         [CCode (cheader_filename = "libsoup/soup.h")]
1065         public static GLib.SList<string> header_parse_quality_list (string header, GLib.SList<string> unacceptable);
1066         [CCode (cheader_filename = "libsoup/soup.h")]
1067         public static GLib.HashTable<string,string> header_parse_semi_param_list (string header);
1068         [CCode (cheader_filename = "libsoup/soup.h")]
1069         public static bool headers_parse (string str, int len, Soup.MessageHeaders dest);
1070         [CCode (cheader_filename = "libsoup/soup.h")]
1071         public static uint headers_parse_request (string str, int len, Soup.MessageHeaders req_headers, out unowned string req_method, out unowned string req_path, Soup.HTTPVersion ver);
1072         [CCode (cheader_filename = "libsoup/soup.h")]
1073         public static bool headers_parse_response (string str, int len, Soup.MessageHeaders headers, Soup.HTTPVersion ver, uint status_code, out unowned string reason_phrase);
1074         [CCode (cheader_filename = "libsoup/soup.h")]
1075         public static bool headers_parse_status_line (string status_line, Soup.HTTPVersion ver, uint status_code, out unowned string reason_phrase);
1076         [CCode (cheader_filename = "libsoup/soup.h")]
1077         public static GLib.Quark http_error_quark ();
1078         [CCode (cheader_filename = "libsoup/soup.h")]
1079         public static GLib.Quark ssl_error_quark ();
1080         [CCode (cheader_filename = "libsoup/soup.h")]
1081         public static unowned string status_get_phrase (uint status_code);
1082         [CCode (cheader_filename = "libsoup/soup.h")]
1083         public static uint status_proxify (uint status_code);
1084         [CCode (cheader_filename = "libsoup/soup.h")]
1085         public static bool str_case_equal (void* v1, void* v2);
1086         [CCode (cheader_filename = "libsoup/soup.h")]
1087         public static uint str_case_hash (void* key);
1088         [CCode (cheader_filename = "libsoup/soup.h")]
1089         public static void value_array_append (GLib.ValueArray array, GLib.Type type);
1090         [CCode (cheader_filename = "libsoup/soup.h")]
1091         public static void value_array_append_vals (GLib.ValueArray array, ...);
1092         [CCode (cheader_filename = "libsoup/soup.h")]
1093         public static unowned GLib.ValueArray value_array_from_args (void* args);
1094         [CCode (cheader_filename = "libsoup/soup.h")]
1095         public static bool value_array_get_nth (GLib.ValueArray array, uint index_, GLib.Type type);
1096         [CCode (cheader_filename = "libsoup/soup.h")]
1097         public static void value_array_insert (GLib.ValueArray array, uint index_, GLib.Type type);
1098         [CCode (cheader_filename = "libsoup/soup.h")]
1099         public static unowned GLib.ValueArray value_array_new ();
1100         [CCode (cheader_filename = "libsoup/soup.h")]
1101         public static unowned GLib.ValueArray value_array_new_with_vals (...);
1102         [CCode (cheader_filename = "libsoup/soup.h")]
1103         public static bool value_array_to_args (GLib.ValueArray array, void* args);
1104         [CCode (cheader_filename = "libsoup/soup.h")]
1105         public static void value_hash_insert (GLib.HashTable<string,GLib.Value> hash, string key, GLib.Type type, ...);
1106         [CCode (cheader_filename = "libsoup/soup.h")]
1107         public static void value_hash_insert_vals (GLib.HashTable<string,GLib.Value> hash, ...);
1108         [CCode (cheader_filename = "libsoup/soup.h")]
1109         public static void value_hash_insert_value (GLib.HashTable<string,GLib.Value> hash, string key, GLib.Value value);
1110         [CCode (cheader_filename = "libsoup/soup.h")]
1111         public static bool value_hash_lookup (GLib.HashTable<string,GLib.Value> hash, string key, GLib.Type type);
1112         [CCode (cheader_filename = "libsoup/soup.h")]
1113         public static bool value_hash_lookup_vals (GLib.HashTable<string,GLib.Value> hash, ...);
1114         [CCode (cheader_filename = "libsoup/soup.h")]
1115         public static GLib.HashTable<string,GLib.Value> value_hash_new ();
1116         [CCode (cheader_filename = "libsoup/soup.h")]
1117         public static GLib.HashTable<string,GLib.Value> value_hash_new_with_vals (...);
1118         [PrintfFormat]
1119         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.build_fault")]
1120         [CCode (cheader_filename = "libsoup/soup.h")]
1121         public static unowned string xmlrpc_build_fault (int fault_code, string fault_format, ...);
1122         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.build_method_call")]
1123         [CCode (cheader_filename = "libsoup/soup.h")]
1124         public static unowned string xmlrpc_build_method_call (string method_name, GLib.Value[] @params);
1125         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.build_method_response")]
1126         [CCode (cheader_filename = "libsoup/soup.h")]
1127         public static unowned string xmlrpc_build_method_response (GLib.Value value);
1128         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.error_quark")]
1129         [CCode (cheader_filename = "libsoup/soup.h")]
1130         public static GLib.Quark xmlrpc_error_quark ();
1131         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.extract_method_call")]
1132         [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
1133         public static bool xmlrpc_extract_method_call (string method_call, int length, out unowned string method_name, ...);
1134         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.extract_method_response")]
1135         [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
1136         public static bool xmlrpc_extract_method_response (string method_response, int length, ...) throws GLib.Error;
1137         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.fault_quark")]
1138         [CCode (cheader_filename = "libsoup/soup.h")]
1139         public static GLib.Quark xmlrpc_fault_quark ();
1140         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.parse_method_call")]
1141         [CCode (cheader_filename = "libsoup/soup.h")]
1142         public static bool xmlrpc_parse_method_call (string method_call, int length, out unowned string method_name, out unowned GLib.ValueArray @params);
1143         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.parse_method_response")]
1144         [CCode (cheader_filename = "libsoup/soup.h")]
1145         public static bool xmlrpc_parse_method_response (string method_response, int length, GLib.Value value) throws GLib.Error;
1146         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.request_new")]
1147         [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
1148         public static unowned Soup.Message xmlrpc_request_new (string uri, string method_name, ...);
1149         [PrintfFormat]
1150         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.set_fault")]
1151         [CCode (cheader_filename = "libsoup/soup.h")]
1152         public static void xmlrpc_set_fault (Soup.Message msg, int fault_code, string fault_format, ...);
1153         [Deprecated (since = "vala-0.12", replacement = "XMLRPC.set_response")]
1154         [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
1155         public static void xmlrpc_set_response (Soup.Message msg, ...);