This file is indexed.

/usr/share/vala-0.14/vapi/libsoup-2.4.vapi is in valac-0.14 0.14.2-0ubuntu1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

   1
   2
   3
   4
   5
   6
   7
   8
   9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186
 187
 188
 189
 190
 191
 192
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286
 287
 288
 289
 290
 291
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322
 323
 324
 325
 326
 327
 328
 329
 330
 331
 332
 333
 334
 335
 336
 337
 338
 339
 340
 341
 342
 343
 344
 345
 346
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395
 396
 397
 398
 399
 400
 401
 402
 403
 404
 405
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495
 496
 497
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539
 540
 541
 542
 543
 544
 545
 546
 547
 548
 549
 550
 551
 552
 553
 554
 555
 556
 557
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590
 591
 592
 593
 594
 595
 596
 597
 598
 599
 600
 601
 602
 603
 604
 605
 606
 607
 608
 609
 610
 611
 612
 613
 614
 615
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656
 657
 658
 659
 660
 661
 662
 663
 664
 665
 666
 667
 668
 669
 670
 671
 672
 673
 674
 675
 676
 677
 678
 679
 680
 681
 682
 683
 684
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699
 700
 701
 702
 703
 704
 705
 706
 707
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721
 722
 723
 724
 725
 726
 727
 728
 729
 730
 731
 732
 733
 734
 735
 736
 737
 738
 739
 740
 741
 742
 743
 744
 745
 746
 747
 748
 749
 750
 751
 752
 753
 754
 755
 756
 757
 758
 759
 760
 761
 762
 763
 764
 765
 766
 767
 768
 769
 770
 771
 772
 773
 774
 775
 776
 777
 778
 779
 780
 781
 782
 783
 784
 785
 786
 787
 788
 789
 790
 791
 792
 793
 794
 795
 796
 797
 798
 799
 800
 801
 802
 803
 804
 805
 806
 807
 808
 809
 810
 811
 812
 813
 814
 815
 816
 817
 818
 819
 820
 821
 822
 823
 824
 825
 826
 827
 828
 829
 830
 831
 832
 833
 834
 835
 836
 837
 838
 839
 840
 841
 842
 843
 844
 845
 846
 847
 848
 849
 850
 851
 852
 853
 854
 855
 856
 857
 858
 859
 860
 861
 862
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
/* libsoup-2.4.vapi generated by vapigen, do not modify. */

[CCode (cprefix = "Soup", gir_namespace = "Soup", gir_version = "2.4", lower_case_cprefix = "soup_")]
namespace Soup {
	namespace Form {
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static GLib.HashTable<string,string> decode (string encoded_form);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static GLib.HashTable<string,string> decode_multipart (Soup.Message msg, string file_control_name, out string filename, out string content_type, out Soup.Buffer file);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static string encode (...);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static string encode_datalist (GLib.Datalist form_data_set);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static string encode_hash (GLib.HashTable<string,string> form_data_set);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static string encode_valist (string first_field, va_list args);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static Soup.Message request_new (string method, string uri, ...);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static Soup.Message request_new_from_datalist (string method, string uri, GLib.Datalist form_data_set);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static Soup.Message request_new_from_hash (string method, string uri, GLib.HashTable<string,string> form_data_set);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static Soup.Message request_new_from_multipart (string uri, Soup.Multipart multipart);
	}
	namespace XMLRPC {
		[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_XMLRPC_ERROR_")]
		[GIR (name = "XMLRPCError")]
		public errordomain Error {
			ARGUMENTS,
			RETVAL
		}
		[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_XMLRPC_FAULT_")]
		[GIR (name = "XMLRPCFault")]
		public errordomain Fault {
			PARSE_ERROR_NOT_WELL_FORMED,
			PARSE_ERROR_UNSUPPORTED_ENCODING,
			PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING,
			SERVER_ERROR_INVALID_XML_RPC,
			SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND,
			SERVER_ERROR_INVALID_METHOD_PARAMETERS,
			SERVER_ERROR_INTERNAL_XML_RPC_ERROR,
			APPLICATION_ERROR,
			SYSTEM_ERROR,
			TRANSPORT_ERROR
		}
		[CCode (cheader_filename = "libsoup/soup.h")]
		[PrintfFormat]
		public static string build_fault (int fault_code, string fault_format, ...);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static string build_method_call (string method_name, [CCode (array_length_cname = "n_params", array_length_pos = 2.1, type = "GValue*")] GLib.Value[] @params);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static string build_method_response (GLib.Value value);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static GLib.Quark error_quark ();
		[CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
		public static bool extract_method_call (string method_call, int length, out string method_name, ...);
		[CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
		public static bool extract_method_response (string method_response, int length, ...) throws Soup.XMLRPC.Fault;
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static GLib.Quark fault_quark ();
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static bool parse_method_call (string method_call, int length, out string method_name, out GLib.ValueArray @params);
		[CCode (cheader_filename = "libsoup/soup.h")]
		public static bool parse_method_response (string method_response, int length, out GLib.Value value) throws Soup.XMLRPC.Fault;
		[CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
		public static Soup.Message request_new (string uri, string method_name, ...);
		[CCode (cheader_filename = "libsoup/soup.h")]
		[PrintfFormat]
		public static void set_fault (Soup.Message msg, int fault_code, string fault_format, ...);
		[CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
		public static void set_response (Soup.Message msg, ...);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_address_get_type ()")]
	public class Address : GLib.Object, GLib.SocketConnectable {
		[CCode (has_construct_function = false)]
		public Address (string name, uint port);
		[CCode (has_construct_function = false)]
		public Address.any (Soup.AddressFamily family, uint port);
		public static bool equal_by_ip ([CCode (type = "gconstpointer")] Soup.Address addr1, [CCode (type = "gconstpointer")] Soup.Address addr2);
		public static bool equal_by_name ([CCode (type = "gconstpointer")] Soup.Address addr1, [CCode (type = "gconstpointer")] Soup.Address addr2);
		[CCode (has_construct_function = false)]
		public Address.from_sockaddr (void* sa, int len);
		public GLib.SocketAddress get_gsockaddr ();
		public unowned string get_name ();
		public unowned string get_physical ();
		public uint get_port ();
		public void* get_sockaddr (int len);
		public static uint hash_by_ip (void* addr);
		public static uint hash_by_name (void* addr);
		public bool is_resolved ();
		public void resolve_async (GLib.MainContext? async_context, GLib.Cancellable? cancellable, Soup.AddressCallback callback);
		public uint resolve_sync (GLib.Cancellable? cancellable);
		[NoAccessorMethod]
		public Soup.AddressFamily family { get; construct; }
		public string name { get; construct; }
		public string physical { get; }
		public int port { get; construct; }
		[NoAccessorMethod]
		public void* sockaddr { get; construct; }
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_auth_get_type ()")]
	public abstract class Auth : GLib.Object {
		[CCode (has_construct_function = false)]
		public Auth (GLib.Type type, Soup.Message msg, string auth_header);
		public virtual void authenticate (string username, string password);
		public virtual string get_authorization (Soup.Message msg);
		public unowned string get_host ();
		public string get_info ();
		public virtual GLib.SList<string> get_protection_space (Soup.URI source_uri);
		public unowned string get_realm ();
		public unowned string get_scheme_name ();
		public virtual bool update (Soup.Message msg, GLib.HashTable<void*,void*> auth_params);
		public string host { get; construct; }
		[NoAccessorMethod]
		public virtual bool is_authenticated { get; }
		[NoAccessorMethod]
		public bool is_for_proxy { get; construct; }
		public string realm { get; construct; }
		public string scheme_name { get; }
		public signal void save_password (string object, string p0);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_auth_domain_get_type ()")]
	public abstract class AuthDomain : GLib.Object {
		[CCode (has_construct_function = false)]
		protected AuthDomain ();
		[NoWrapper]
		public virtual string accepts (Soup.Message msg, string header);
		public void add_path (string path);
		[CCode (vfunc_name = "challenge")]
		public virtual string challenge (Soup.Message msg);
		public virtual bool check_password (Soup.Message msg, string username, string password);
		public bool covers (Soup.Message msg);
		public unowned string get_realm ();
		public void remove_path (string path);
		public void set_filter (owned Soup.AuthDomainFilter filter);
		public void set_generic_auth_callback (owned Soup.AuthDomainGenericAuthCallback auth_callback);
		public bool try_generic_auth_callback (Soup.Message msg, string username);
		[NoAccessorMethod]
		public void* filter { get; set; }
		[NoAccessorMethod]
		public void* filter_data { get; set; }
		[NoAccessorMethod]
		public void* generic_auth_callback { get; set; }
		[NoAccessorMethod]
		public void* generic_auth_data { get; set; }
		[NoAccessorMethod]
		public bool proxy { get; construct; }
		public string realm { get; construct; }
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_auth_domain_basic_get_type ()")]
	public class AuthDomainBasic : Soup.AuthDomain {
		[CCode (has_construct_function = false, type = "SoupAuthDomain*")]
		public AuthDomainBasic (string optname1, ...);
		public static void set_auth_callback (Soup.AuthDomain domain, owned Soup.AuthDomainBasicAuthCallback callback);
		[NoAccessorMethod]
		public void* auth_callback { get; set; }
		[NoAccessorMethod]
		public void* auth_data { get; set; }
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_auth_domain_digest_get_type ()")]
	public class AuthDomainDigest : Soup.AuthDomain {
		[CCode (has_construct_function = false, type = "SoupAuthDomain*")]
		public AuthDomainDigest (string optname1, ...);
		public static string encode_password (string username, string realm, string password);
		public static void set_auth_callback (Soup.AuthDomain domain, owned Soup.AuthDomainDigestAuthCallback callback);
		[NoAccessorMethod]
		public void* auth_callback { get; set; }
		[NoAccessorMethod]
		public void* auth_data { get; set; }
	}
	[CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_buffer_get_type ()")]
	[Compact]
	public class Buffer {
		[CCode (array_length_cname = "length", array_length_type = "gsize")]
		public uint8[] data;
		public size_t length;
		[CCode (has_construct_function = false)]
		public Buffer (Soup.MemoryUse use, [CCode (array_length_cname = "length", array_length_pos = 2.1, array_length_type = "gsize", type = "gconstpointer")] uint8[] data);
		public Soup.Buffer copy ();
		public void free ();
		public void get_data ([CCode (array_length_cname = "length", array_length_pos = 1.1, array_length_type = "gsize")] out unowned uint8[] data);
		public void* get_owner ();
		[CCode (has_construct_function = false)]
		public Buffer.subbuffer (Soup.Buffer parent, size_t offset, size_t length);
		[CCode (has_construct_function = false)]
		public Buffer.take ([CCode (array_length_cname = "length", array_length_pos = 1.1, array_length_type = "gsize")] owned uint8[] data);
		[CCode (has_construct_function = false)]
		public Buffer.with_owner ([CCode (array_length_cname = "length", array_length_pos = 1.5, array_length_type = "gsize", type = "gconstpointer")] uint8[] data, void* owner, GLib.DestroyNotify? owner_dnotify);
	}
	[CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_byte_array_get_type ()")]
	[Compact]
	public class ByteArray {
	}
	[CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_client_context_get_type ()")]
	[Compact]
	public class ClientContext {
		public unowned Soup.Address get_address ();
		public unowned Soup.AuthDomain get_auth_domain ();
		public unowned string get_auth_user ();
		public unowned string get_host ();
		public unowned Soup.Socket get_socket ();
	}
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Compact]
	public class Connection {
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_content_decoder_get_type ()")]
	public class ContentDecoder : GLib.Object, Soup.SessionFeature {
		[CCode (has_construct_function = false)]
		protected ContentDecoder ();
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_content_sniffer_get_type ()")]
	public class ContentSniffer : GLib.Object, Soup.SessionFeature {
		[CCode (has_construct_function = false)]
		public ContentSniffer ();
		[NoWrapper]
		public virtual size_t get_buffer_size ();
		public virtual string sniff (Soup.Message msg, Soup.Buffer buffer, out GLib.HashTable<string,string>? @params);
	}
	[CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_cookie_get_type ()")]
	[Compact]
	public class Cookie {
		public weak string domain;
		public weak Soup.Date expires;
		public bool http_only;
		public weak string name;
		public weak string path;
		public bool secure;
		public weak string value;
		[CCode (has_construct_function = false)]
		public Cookie (string name, string value, string domain, string path, int max_age);
		public bool applies_to_uri (Soup.URI uri);
		public Soup.Cookie copy ();
		public bool domain_matches (string host);
		public bool equal (Soup.Cookie cookie2);
		public void free ();
		public unowned string get_domain ();
		public unowned Soup.Date get_expires ();
		public bool get_http_only ();
		public unowned string get_name ();
		public unowned string get_path ();
		public bool get_secure ();
		public unowned string get_value ();
		public static Soup.Cookie parse (string header, Soup.URI origin);
		public void set_domain (string domain);
		public void set_expires (Soup.Date expires);
		public void set_http_only (bool http_only);
		public void set_max_age (int max_age);
		public void set_name (string name);
		public void set_path (string path);
		public void set_secure (bool secure);
		public void set_value (string value);
		public string to_cookie_header ();
		public string to_set_cookie_header ();
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_cookie_jar_get_type ()")]
	public class CookieJar : GLib.Object, Soup.SessionFeature {
		[CCode (has_construct_function = false)]
		public CookieJar ();
		public void add_cookie (Soup.Cookie cookie);
		public GLib.SList<Soup.Cookie> all_cookies ();
		public void delete_cookie (Soup.Cookie cookie);
		public Soup.CookieJarAcceptPolicy get_accept_policy ();
		public string get_cookies (Soup.URI uri, bool for_http);
		public virtual void save ();
		public void set_accept_policy (Soup.CookieJarAcceptPolicy policy);
		public void set_cookie (Soup.URI uri, string cookie);
		public void set_cookie_with_first_party (Soup.URI uri, Soup.URI first_party, string cookie);
		public Soup.CookieJarAcceptPolicy accept_policy { get; set; }
		[NoAccessorMethod]
		public bool read_only { get; construct; }
		public virtual signal void changed (Soup.Cookie old_cookie, Soup.Cookie new_cookie);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_cookie_jar_text_get_type ()")]
	public class CookieJarText : Soup.CookieJar, Soup.SessionFeature {
		[CCode (has_construct_function = false, type = "SoupCookieJar*")]
		public CookieJarText (string filename, bool read_only);
		[NoAccessorMethod]
		public string filename { owned get; construct; }
	}
	[CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_date_get_type ()")]
	[Compact]
	public class Date {
		public int day;
		public int hour;
		public int minute;
		public int month;
		public int offset;
		public int second;
		public bool utc;
		public int year;
		[CCode (has_construct_function = false)]
		public Date (int year, int month, int day, int hour, int minute, int second);
		public Soup.Date copy ();
		public void free ();
		[CCode (has_construct_function = false)]
		public Date.from_now (int offset_seconds);
		[CCode (has_construct_function = false)]
		public Date.from_string (string date_string);
		[CCode (has_construct_function = false)]
		public Date.from_time_t ([CCode (type = "time_t")] time_t when);
		public int get_day ();
		public int get_hour ();
		public int get_minute ();
		public int get_month ();
		public int get_offset ();
		public int get_second ();
		public int get_utc ();
		public int get_year ();
		public bool is_past ();
		public string to_string (Soup.DateFormat format);
		public time_t to_time_t ();
		public GLib.TimeVal to_timeval ();
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_logger_get_type ()")]
	public class Logger : GLib.Object, Soup.SessionFeature {
		[CCode (has_construct_function = false)]
		public Logger (Soup.LoggerLogLevel level, int max_body_size);
		public void set_printer (owned Soup.LoggerPrinter printer);
		public void set_request_filter (owned Soup.LoggerFilter request_filter);
		public void set_response_filter (owned Soup.LoggerFilter response_filter);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_message_get_type ()")]
	public class Message : GLib.Object {
		public weak Soup.MessageBody request_body;
		public weak Soup.MessageHeaders request_headers;
		public weak Soup.MessageBody response_body;
		public weak Soup.MessageHeaders response_headers;
		[CCode (has_construct_function = false)]
		public Message (string method, string uri_string);
		public uint add_header_handler (string @signal, string header, GLib.Callback callback);
		public uint add_status_code_handler (string @signal, uint status_code, GLib.Callback callback);
		public void disable_feature (GLib.Type feature_type);
		[CCode (has_construct_function = false)]
		public Message.from_uri (string method, Soup.URI uri);
		public unowned Soup.Address get_address ();
		public unowned Soup.URI get_first_party ();
		public Soup.MessageFlags get_flags ();
		public Soup.HTTPVersion get_http_version ();
		public unowned Soup.URI get_uri ();
		public bool is_keepalive ();
		public void set_chunk_allocator (owned Soup.ChunkAllocator allocator);
		public void set_first_party (Soup.URI first_party);
		public void set_flags (Soup.MessageFlags flags);
		public void set_http_version (Soup.HTTPVersion version);
		public void set_request (string content_type, Soup.MemoryUse req_use, [CCode (array_length_cname = "req_length", array_length_pos = 3.1, array_length_type = "gsize", type = "char*")] uint8[] req_body);
		public void set_response (string? content_type, Soup.MemoryUse resp_use, [CCode (array_length_cname = "resp_length", array_length_pos = 3.1, array_length_type = "gsize")] uint8[] resp_body);
		public void set_status (uint status_code);
		public void set_status_full (uint status_code, string reason_phrase);
		public void set_uri (Soup.URI uri);
		public Soup.URI first_party { get; set; }
		public Soup.MessageFlags flags { get; set; }
		public Soup.HTTPVersion http_version { get; set; }
		[NoAccessorMethod]
		public string method { owned get; set; }
		[NoAccessorMethod]
		public string reason_phrase { owned get; set; }
		[NoAccessorMethod]
		public bool server_side { get; construct; }
		[NoAccessorMethod]
		public uint status_code { get; set; }
		public Soup.URI uri { get; set; }
		[HasEmitter]
		public signal void content_sniffed (string content_type, GLib.HashTable<void*,void*> @params);
		[HasEmitter]
		public virtual signal void finished ();
		[HasEmitter]
		public virtual signal void got_body ();
		[HasEmitter]
		public virtual signal void got_chunk (Soup.Buffer chunk);
		[HasEmitter]
		public virtual signal void got_headers ();
		[HasEmitter]
		public virtual signal void got_informational ();
		[HasEmitter]
		public virtual signal void restarted ();
		[HasEmitter]
		public virtual signal void wrote_body ();
		[HasEmitter]
		public signal void wrote_body_data (Soup.Buffer chunk);
		[HasEmitter]
		public virtual signal void wrote_chunk ();
		[HasEmitter]
		public virtual signal void wrote_headers ();
		[HasEmitter]
		public virtual signal void wrote_informational ();
	}
	[CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_message_body_get_type ()")]
	[Compact]
	public class MessageBody {
		[CCode (array_length_cname = "length", array_length_type = "gint64")]
		public uint8[] data;
		public int64 length;
		[CCode (has_construct_function = false)]
		public MessageBody ();
		public void append (Soup.MemoryUse use, [CCode (array_length_cname = "length", array_length_pos = 2.1, array_length_type = "gsize")] uint8[] data);
		public void append_buffer (Soup.Buffer buffer);
		public void append_take ([CCode (array_length_cname = "length", array_length_pos = 1.1, array_length_type = "gsize")] owned uint8[] data);
		public void complete ();
		public Soup.Buffer flatten ();
		public void free ();
		public bool get_accumulate ();
		public Soup.Buffer get_chunk (int64 offset);
		public void got_chunk (Soup.Buffer chunk);
		public void set_accumulate (bool accumulate);
		public void truncate ();
		public void wrote_chunk (Soup.Buffer chunk);
	}
	[CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_message_headers_get_type ()")]
	[Compact]
	public class MessageHeaders {
		[CCode (has_construct_function = false)]
		public MessageHeaders (Soup.MessageHeadersType type);
		public void append (string name, string value);
		public void clear ();
		public void @foreach (Soup.MessageHeadersForeachFunc func);
		public void free ();
		public void free_ranges (Soup.Range ranges);
		public unowned string @get (string name);
		public bool get_content_disposition (out string disposition, out GLib.HashTable<string,string> @params);
		public int64 get_content_length ();
		public bool get_content_range (int64 start, int64 end, int64 total_length);
		public unowned string get_content_type (out GLib.HashTable<string,string> @params);
		public Soup.Encoding get_encoding ();
		public Soup.Expectation get_expectations ();
		public unowned string get_list (string name);
		public unowned string get_one (string name);
		public bool get_ranges (int64 total_length, out Soup.Range ranges, int length);
		public void remove (string name);
		public void replace (string name, string value);
		public void set_content_disposition (string disposition, GLib.HashTable<string,string>? @params);
		public void set_content_length (int64 content_length);
		public void set_content_range (int64 start, int64 end, int64 total_length);
		public void set_content_type (string content_type, GLib.HashTable<string,string>? @params);
		public void set_encoding (Soup.Encoding encoding);
		public void set_expectations (Soup.Expectation expectations);
		public void set_range (int64 start, int64 end);
		public void set_ranges (Soup.Range ranges, int length);
	}
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Compact]
	public class MessageQueue {
	}
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Compact]
	public class MessageQueueItem {
	}
	[CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_multipart_get_type ()")]
	[Compact]
	public class Multipart {
		[CCode (has_construct_function = false)]
		public Multipart (string mime_type);
		public void append_form_file (string control_name, string filename, string content_type, Soup.Buffer body);
		public void append_form_string (string control_name, string data);
		public void append_part (Soup.MessageHeaders headers, Soup.Buffer body);
		public void free ();
		[CCode (has_construct_function = false)]
		public Multipart.from_message (Soup.MessageHeaders headers, Soup.MessageBody body);
		public int get_length ();
		public bool get_part (int part, out unowned Soup.MessageHeaders headers, out unowned Soup.Buffer body);
		public void to_message (Soup.MessageHeaders dest_headers, Soup.MessageBody dest_body);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_server_get_type ()")]
	public class Server : GLib.Object {
		[CCode (has_construct_function = false)]
		public Server (string optname1, ...);
		public void add_auth_domain (Soup.AuthDomain auth_domain);
		public void add_handler (string? path, owned Soup.ServerCallback callback);
		public unowned GLib.MainContext get_async_context ();
		public unowned Soup.Socket get_listener ();
		public uint get_port ();
		public bool is_https ();
		public void pause_message (Soup.Message msg);
		public void quit ();
		public void remove_auth_domain (Soup.AuthDomain auth_domain);
		public void remove_handler (string path);
		public void run ();
		public void run_async ();
		public void unpause_message (Soup.Message msg);
		public GLib.MainContext async_context { get; owned construct; }
		[NoAccessorMethod]
		public Soup.Address @interface { owned get; construct; }
		public uint port { get; construct; }
		[NoAccessorMethod]
		public bool raw_paths { get; construct; }
		[NoAccessorMethod]
		public string server_header { owned get; set construct; }
		[NoAccessorMethod]
		public string ssl_cert_file { owned get; construct; }
		[NoAccessorMethod]
		public string ssl_key_file { owned get; construct; }
		public virtual signal void request_aborted (Soup.Message msg, Soup.ClientContext client);
		public virtual signal void request_finished (Soup.Message msg, Soup.ClientContext client);
		public virtual signal void request_read (Soup.Message msg, Soup.ClientContext client);
		public virtual signal void request_started (Soup.Message msg, Soup.ClientContext client);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_session_get_type ()")]
	public abstract class Session : GLib.Object {
		[CCode (has_construct_function = false)]
		protected Session ();
		public void abort ();
		[NoWrapper]
		public virtual void auth_required (Soup.Message msg, Soup.Auth auth, bool retrying);
		public virtual void cancel_message (Soup.Message msg, uint status_code);
		public unowned GLib.MainContext get_async_context ();
		public unowned Soup.SessionFeature get_feature (GLib.Type feature_type);
		public unowned Soup.SessionFeature get_feature_for_message (GLib.Type feature_type, Soup.Message msg);
		public GLib.SList<Soup.SessionFeature> get_features (GLib.Type feature_type);
		public void pause_message (Soup.Message msg);
		public void prepare_for_uri (Soup.URI uri);
		public virtual void queue_message (owned Soup.Message msg, Soup.SessionCallback? callback);
		public void remove_feature (Soup.SessionFeature feature);
		public virtual void requeue_message (Soup.Message msg);
		public virtual uint send_message (Soup.Message msg);
		public void unpause_message (Soup.Message msg);
		[NoAccessorMethod]
		public string accept_language { owned get; set; }
		[NoAccessorMethod]
		public bool accept_language_auto { get; set; }
		[NoAccessorMethod]
		public Soup.SessionFeature add_feature { owned get; set; }
		[NoAccessorMethod]
		public GLib.Type add_feature_by_type { get; set; }
		public GLib.MainContext async_context { get; owned construct; }
		[NoAccessorMethod]
		public uint idle_timeout { get; set; }
		[NoAccessorMethod]
		public int max_conns { get; set; }
		[NoAccessorMethod]
		public int max_conns_per_host { get; set; }
		[NoAccessorMethod]
		public Soup.URI proxy_uri { owned get; set; }
		[NoAccessorMethod]
		public GLib.Type remove_feature_by_type { get; set; }
		[NoAccessorMethod]
		public string ssl_ca_file { owned get; set; }
		[NoAccessorMethod]
		public bool ssl_strict { get; set; }
		[NoAccessorMethod]
		public uint timeout { get; set; }
		[NoAccessorMethod]
		public bool use_ntlm { get; set; }
		[NoAccessorMethod]
		public string user_agent { owned get; set; }
		public virtual signal void authenticate (Soup.Message msg, Soup.Auth auth, bool retrying);
		public signal void connection_created (GLib.Object object);
		public signal void request_queued (Soup.Message object);
		public virtual signal void request_started (Soup.Message msg, Soup.Socket socket);
		public signal void request_unqueued (Soup.Message object);
		public signal void tunneling (GLib.Object object);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_session_async_get_type ()")]
	public class SessionAsync : Soup.Session {
		[CCode (has_construct_function = false, type = "SoupSession*")]
		public SessionAsync ();
		[CCode (has_construct_function = false, type = "SoupSession*")]
		public SessionAsync.with_options (string optname1, ...);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_session_sync_get_type ()")]
	public class SessionSync : Soup.Session {
		[CCode (has_construct_function = false, type = "SoupSession*")]
		public SessionSync ();
		[CCode (has_construct_function = false, type = "SoupSession*")]
		public SessionSync.with_options (string optname1, ...);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_socket_get_type ()")]
	public class Socket : GLib.Object {
		[CCode (has_construct_function = false)]
		public Socket (string optname1, ...);
		public void connect_async (GLib.Cancellable? cancellable, Soup.SocketCallback callback);
		public uint connect_sync (GLib.Cancellable? cancellable);
		public void disconnect ();
		public int get_fd ();
		public unowned Soup.Address get_local_address ();
		public unowned Soup.Address get_remote_address ();
		public bool is_connected ();
		public bool is_ssl ();
		public bool listen ();
		public Soup.SocketIOStatus read ([CCode (array_length_cname = "len", array_length_pos = 1.5, array_length_type = "gsize", type = "gpointer")] uint8[] buffer, out size_t nread, GLib.Cancellable? cancellable) throws GLib.Error;
		public Soup.SocketIOStatus read_until ([CCode (array_length_cname = "len", array_length_pos = 1.5, array_length_type = "gsize", type = "gpointer")] uint8[] buffer, void* boundary, size_t boundary_len, out size_t nread, bool got_boundary, GLib.Cancellable? cancellable) throws GLib.Error;
		public bool start_proxy_ssl (string ssl_host, GLib.Cancellable? cancellable);
		public bool start_ssl (GLib.Cancellable? cancellable);
		public Soup.SocketIOStatus write ([CCode (array_length_cname = "len", array_length_pos = 1.5, array_length_type = "gsize", type = "gconstpointer")] uint8[] buffer, out size_t nwrote, GLib.Cancellable? cancellable) throws GLib.Error;
		[NoAccessorMethod]
		public GLib.MainContext async_context { owned get; construct; }
		public bool clean_dispose { construct; }
		[NoAccessorMethod]
		public bool is_server { get; }
		public Soup.Address local_address { get; construct; }
		[NoAccessorMethod]
		public bool non_blocking { get; set; }
		public Soup.Address remote_address { get; construct; }
		[NoAccessorMethod]
		public void* ssl_creds { get; set; }
		[NoAccessorMethod]
		public bool ssl_strict { get; construct; }
		[NoAccessorMethod]
		public uint timeout { get; set; }
		[NoAccessorMethod]
		public bool trusted_certificate { get; construct; }
		public virtual signal void disconnected ();
		public virtual signal void new_connection (Soup.Socket arg1);
		public virtual signal void readable ();
		public virtual signal void writable ();
	}
	[CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_uri_get_type ()")]
	[Compact]
	public class URI {
		public weak string fragment;
		public weak string host;
		public weak string password;
		public weak string path;
		public uint port;
		public weak string query;
		public weak string scheme;
		public weak string user;
		[CCode (has_construct_function = false)]
		public URI (string uri_string);
		public Soup.URI copy ();
		public Soup.URI copy_host ();
		public static string decode (string part);
		public static string encode (string part, string? escape_extra);
		public bool equal (Soup.URI uri2);
		public void free ();
		public unowned string get_fragment ();
		public unowned string get_host ();
		public unowned string get_password ();
		public unowned string get_path ();
		public uint get_port ();
		public unowned string get_query ();
		public unowned string get_scheme ();
		public unowned string get_user ();
		public static bool host_equal ([CCode (type = "gconstpointer")] Soup.URI v1, [CCode (type = "gconstpointer")] Soup.URI v2);
		public static uint host_hash ([CCode (type = "gconstpointer")] Soup.URI key);
		public static string normalize (string part, string unescape_extra);
		public void set_fragment (string fragment);
		public void set_host (string host);
		public void set_password (string password);
		public void set_path (string path);
		public void set_port (uint port);
		public void set_query (string query);
		public void set_query_from_fields (...);
		public void set_query_from_form (GLib.HashTable<string,string> form);
		public void set_scheme (string scheme);
		public void set_user (string user);
		public string to_string (bool just_path_and_query);
		public bool uses_default_port ();
		[CCode (has_construct_function = false)]
		public URI.with_base (Soup.URI @base, string uri_string);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_cname = "SoupProxyResolverInterface", type_id = "soup_proxy_resolver_get_type ()")]
	public interface ProxyResolver : Soup.SessionFeature, GLib.Object {
		public abstract void get_proxy_async (Soup.Message msg, GLib.MainContext async_context, GLib.Cancellable? cancellable, Soup.ProxyResolverCallback callaback);
		public abstract uint get_proxy_sync (Soup.Message msg, GLib.Cancellable? cancellable, out unowned Soup.Address addr);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_cname = "SoupProxyURIResolverInterface", type_id = "soup_proxy_uri_resolver_get_type ()")]
	public interface ProxyURIResolver : GLib.Object {
		public abstract void get_proxy_uri_async (Soup.URI uri, GLib.MainContext? async_context, GLib.Cancellable? cancellable, Soup.ProxyURIResolverCallback callback);
		public abstract uint get_proxy_uri_sync (Soup.URI uri, GLib.Cancellable? cancellable, out unowned Soup.URI proxy_uri);
	}
	[CCode (cheader_filename = "libsoup/soup.h", type_cname = "SoupSessionFeatureInterface", type_id = "soup_session_feature_get_type ()")]
	public interface SessionFeature : GLib.Object {
		public abstract void attach (Soup.Session session);
		public abstract void detach (Soup.Session session);
		[NoWrapper]
		public abstract void request_queued (Soup.Session session, Soup.Message msg);
		[NoWrapper]
		public abstract void request_started (Soup.Session session, Soup.Message msg, Soup.Socket socket);
		[NoWrapper]
		public abstract void request_unqueued (Soup.Session session, Soup.Message msg);
	}
	[CCode (cheader_filename = "libsoup/soup.h", has_type_id = false)]
	public struct MessageHeadersIter {
		[CCode (array_length = false, array_null_terminated = true)]
		public weak void*[] dummy;
		public void init (Soup.MessageHeaders hdrs);
		public bool next (out unowned string name, out unowned string value);
	}
	[CCode (cheader_filename = "libsoup/soup.h", has_type_id = false)]
	public struct Range {
		public int64 start;
		public int64 end;
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_ADDRESS_FAMILY_")]
	public enum AddressFamily {
		INVALID,
		IPV4,
		IPV6
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_CONNECTION_")]
	public enum ConnectionState {
		NEW,
		CONNECTING,
		IDLE,
		IN_USE,
		REMOTE_DISCONNECTED,
		DISCONNECTED
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_COOKIE_JAR_ACCEPT_")]
	public enum CookieJarAcceptPolicy {
		ALWAYS,
		NEVER,
		NO_THIRD_PARTY
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_DATE_")]
	public enum DateFormat {
		HTTP,
		COOKIE,
		RFC2822,
		ISO8601_COMPACT,
		ISO8601_FULL,
		ISO8601,
		ISO8601_XMLRPC
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_ENCODING_")]
	public enum Encoding {
		UNRECOGNIZED,
		NONE,
		CONTENT_LENGTH,
		EOF,
		CHUNKED,
		BYTERANGES
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_EXPECTATION_")]
	[Flags]
	public enum Expectation {
		UNRECOGNIZED,
		CONTINUE
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_HTTP_")]
	public enum HTTPVersion {
		@1_0,
		@1_1
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_STATUS_")]
	public enum KnownStatusCode {
		NONE,
		CANCELLED,
		CANT_RESOLVE,
		CANT_RESOLVE_PROXY,
		CANT_CONNECT,
		CANT_CONNECT_PROXY,
		SSL_FAILED,
		IO_ERROR,
		MALFORMED,
		TRY_AGAIN,
		TOO_MANY_REDIRECTS,
		CONTINUE,
		SWITCHING_PROTOCOLS,
		PROCESSING,
		OK,
		CREATED,
		ACCEPTED,
		NON_AUTHORITATIVE,
		NO_CONTENT,
		RESET_CONTENT,
		PARTIAL_CONTENT,
		MULTI_STATUS,
		MULTIPLE_CHOICES,
		MOVED_PERMANENTLY,
		FOUND,
		MOVED_TEMPORARILY,
		SEE_OTHER,
		NOT_MODIFIED,
		USE_PROXY,
		NOT_APPEARING_IN_THIS_PROTOCOL,
		TEMPORARY_REDIRECT,
		BAD_REQUEST,
		UNAUTHORIZED,
		PAYMENT_REQUIRED,
		FORBIDDEN,
		NOT_FOUND,
		METHOD_NOT_ALLOWED,
		NOT_ACCEPTABLE,
		PROXY_AUTHENTICATION_REQUIRED,
		PROXY_UNAUTHORIZED,
		REQUEST_TIMEOUT,
		CONFLICT,
		GONE,
		LENGTH_REQUIRED,
		PRECONDITION_FAILED,
		REQUEST_ENTITY_TOO_LARGE,
		REQUEST_URI_TOO_LONG,
		UNSUPPORTED_MEDIA_TYPE,
		REQUESTED_RANGE_NOT_SATISFIABLE,
		INVALID_RANGE,
		EXPECTATION_FAILED,
		UNPROCESSABLE_ENTITY,
		LOCKED,
		FAILED_DEPENDENCY,
		INTERNAL_SERVER_ERROR,
		NOT_IMPLEMENTED,
		BAD_GATEWAY,
		SERVICE_UNAVAILABLE,
		GATEWAY_TIMEOUT,
		HTTP_VERSION_NOT_SUPPORTED,
		INSUFFICIENT_STORAGE,
		NOT_EXTENDED
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_LOGGER_LOG_")]
	public enum LoggerLogLevel {
		NONE,
		MINIMAL,
		HEADERS,
		BODY
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_MEMORY_")]
	public enum MemoryUse {
		STATIC,
		TAKE,
		COPY,
		TEMPORARY
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_MESSAGE_")]
	[Flags]
	public enum MessageFlags {
		NO_REDIRECT,
		OVERWRITE_CHUNKS,
		CONTENT_DECODED,
		CERTIFICATE_TRUSTED
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_MESSAGE_HEADERS_")]
	public enum MessageHeadersType {
		REQUEST,
		RESPONSE,
		MULTIPART
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_SOCKET_")]
	public enum SocketIOStatus {
		OK,
		WOULD_BLOCK,
		EOF,
		ERROR
	}
	[CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_SSL_ERROR_")]
	public errordomain SSLError {
		HANDSHAKE_NEEDS_READ,
		HANDSHAKE_NEEDS_WRITE,
		CERTIFICATE,
		HANDSHAKE_FAILED;
		public static GLib.Quark quark ();
	}
	[CCode (cheader_filename = "libsoup/soup.h", has_target = false)]
	public delegate void AddressCallback (Soup.Address addr, uint status);
	[CCode (cheader_filename = "libsoup/soup.h", instance_pos = 4.9)]
	public delegate bool AuthDomainBasicAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username, string password);
	[CCode (cheader_filename = "libsoup/soup.h", instance_pos = 3.9)]
	public delegate string AuthDomainDigestAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username);
	[CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)]
	public delegate bool AuthDomainFilter (Soup.AuthDomain domain, Soup.Message msg);
	[CCode (cheader_filename = "libsoup/soup.h", instance_pos = 3.9)]
	public delegate bool AuthDomainGenericAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username);
	[CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)]
	public delegate Soup.Buffer ChunkAllocator (Soup.Message msg, size_t max_len);
	[CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)]
	public delegate Soup.LoggerLogLevel LoggerFilter (Soup.Logger logger, Soup.Message msg);
	[CCode (cheader_filename = "libsoup/soup.h", instance_pos = 4.9)]
	public delegate void LoggerPrinter (Soup.Logger logger, Soup.LoggerLogLevel level, char direction, string data);
	[CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)]
	public delegate void MessageHeadersForeachFunc (string name, string value);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public delegate void ProxyResolverCallback (Soup.ProxyResolver p1, Soup.Message p2, uint p3, Soup.Address p4);
	[CCode (cheader_filename = "libsoup/soup.h", has_target = false)]
	public delegate void ProxyURIResolverCallback (Soup.ProxyURIResolver resolver, uint status, Soup.URI proxy_uri);
	[CCode (cheader_filename = "libsoup/soup.h", instance_pos = 5.9)]
	public delegate void ServerCallback (Soup.Server server, Soup.Message msg, string path, GLib.HashTable<string,string>? query, Soup.ClientContext client);
	[CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)]
	public delegate void SessionCallback (Soup.Session session, Soup.Message msg);
	[CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)]
	public delegate void SocketCallback (Soup.Socket sock, uint status);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int ADDRESS_ANY_PORT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string ADDRESS_FAMILY;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string ADDRESS_NAME;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string ADDRESS_PHYSICAL;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string ADDRESS_PORT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string ADDRESS_SOCKADDR;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_ADD_PATH;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_BASIC_AUTH_CALLBACK;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_BASIC_AUTH_DATA;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int AUTH_DOMAIN_BASIC_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_DIGEST_AUTH_CALLBACK;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_DIGEST_AUTH_DATA;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int AUTH_DOMAIN_DIGEST_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_FILTER;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_FILTER_DATA;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_GENERIC_AUTH_CALLBACK;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_GENERIC_AUTH_DATA;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int AUTH_DOMAIN_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_PROXY;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_REALM;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_DOMAIN_REMOVE_PATH;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int AUTH_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_HOST;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_IS_AUTHENTICATED;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_IS_FOR_PROXY;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_REALM;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string AUTH_SCHEME_NAME;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int CHAR_HTTP_CTL;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int CHAR_HTTP_SEPARATOR;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int CHAR_URI_GEN_DELIMS;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int CHAR_URI_PERCENT_ENCODED;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int CHAR_URI_SUB_DELIMS;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int CONTENT_DECODER_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int CONTENT_SNIFFER_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int COOKIE_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string COOKIE_JAR_ACCEPT_POLICY;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int COOKIE_JAR_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string COOKIE_JAR_READ_ONLY;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string COOKIE_JAR_TEXT_FILENAME;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int COOKIE_JAR_TEXT_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int COOKIE_MAX_AGE_ONE_DAY;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int COOKIE_MAX_AGE_ONE_HOUR;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int COOKIE_MAX_AGE_ONE_WEEK;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int COOKIE_MAX_AGE_ONE_YEAR;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int DATE_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int FORM_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string FORM_MIME_TYPE_MULTIPART;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string FORM_MIME_TYPE_URLENCODED;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int HEADERS_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int LOGGER_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int MESSAGE_BODY_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_FIRST_PARTY;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_FLAGS;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int MESSAGE_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int MESSAGE_HEADERS_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_HTTP_VERSION;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_METHOD;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_REASON_PHRASE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_REQUEST_BODY;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_REQUEST_HEADERS;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_RESPONSE_BODY;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_RESPONSE_HEADERS;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_SERVER_SIDE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_STATUS_CODE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string MESSAGE_URI;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int METHOD_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int MISC_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int MULTIPART_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int PASSWORD_MANAGER_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int PROXY_RESOLVER_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int PROXY_URI_RESOLVER_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SERVER_ASYNC_CONTEXT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int SERVER_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SERVER_INTERFACE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SERVER_PORT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SERVER_RAW_PATHS;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SERVER_SERVER_HEADER;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SERVER_SSL_CERT_FILE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SERVER_SSL_KEY_FILE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_ACCEPT_LANGUAGE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_ACCEPT_LANGUAGE_AUTO;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_ADD_FEATURE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_ADD_FEATURE_BY_TYPE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_ASYNC_CONTEXT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int SESSION_ASYNC_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int SESSION_FEATURE_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int SESSION_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_IDLE_TIMEOUT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_MAX_CONNS;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_MAX_CONNS_PER_HOST;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_PROXY_URI;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_REMOVE_FEATURE_BY_TYPE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_SSL_CA_FILE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_SSL_STRICT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int SESSION_SYNC_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_TIMEOUT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_USER_AGENT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SESSION_USE_NTLM;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SOCKET_ASYNC_CONTEXT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SOCKET_FLAG_NONBLOCKING;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int SOCKET_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SOCKET_IS_SERVER;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SOCKET_LOCAL_ADDRESS;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SOCKET_REMOTE_ADDRESS;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SOCKET_SSL_CREDENTIALS;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SOCKET_SSL_STRICT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SOCKET_TIMEOUT;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const string SOCKET_TRUSTED_CERTIFICATE;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int STATUS_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int TYPES_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int URI_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int VALUE_UTILS_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public const int XMLRPC_H;
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static unowned GLib.TimeoutSource add_completion (GLib.MainContext? async_context, GLib.SourceFunc function);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static unowned GLib.TimeoutSource add_idle (GLib.MainContext? async_context, GLib.SourceFunc function);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static unowned GLib.TimeoutSource add_io_watch (GLib.MainContext? async_context, GLib.IOChannel chan, GLib.IOCondition condition, GLib.IOFunc function);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static unowned GLib.TimeoutSource add_timeout (GLib.MainContext? async_context, uint interval, GLib.SourceFunc function);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.SList<Soup.Cookie> cookies_from_request (Soup.Message msg);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.SList<Soup.Cookie> cookies_from_response (Soup.Message msg);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static string cookies_to_cookie_header (GLib.SList<Soup.Cookie> cookies);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static void cookies_to_request (GLib.SList<Soup.Cookie> cookies, Soup.Message msg);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static void cookies_to_response (GLib.SList<Soup.Cookie> cookies, Soup.Message msg);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "Form.decode", since = "vala-0.12")]
	public static GLib.HashTable<string,string> form_decode (string encoded_form);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "Form.decode_multipart", since = "vala-0.12")]
	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);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "Form.encode", since = "vala-0.12")]
	public static string form_encode (...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "Form.encode_datalist", since = "vala-0.12")]
	public static string form_encode_datalist (void* form_data_set);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "Form.encode_hash", since = "vala-0.12")]
	public static string form_encode_hash (GLib.HashTable<string,string> form_data_set);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (since = "vala-0.12")]
	public static string form_encode_valist (string first_field, void* args);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "Form.request_new", since = "vala-0.12")]
	public static Soup.Message form_request_new (string method, string uri, ...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "Form.request_new_from_datalist", since = "vala-0.12")]
	public static Soup.Message form_request_new_from_datalist (string method, string uri, void* form_data_set);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "Form.request_new_from_hash", since = "vala-0.12")]
	public static Soup.Message form_request_new_from_hash (string method, string uri, GLib.HashTable<string,string> form_data_set);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "Form.request_new_from_multipart", since = "vala-0.12")]
	public static Soup.Message form_request_new_from_multipart (string uri, Soup.Multipart multipart);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static bool header_contains (string header, string token);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static void header_free_param_list (GLib.HashTable<string,string> param_list);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static void header_g_string_append_param (GLib.StringBuilder string, string name, string value);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static void header_g_string_append_param_quoted (GLib.StringBuilder string, string name, string value);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.SList<string> header_parse_list (string header);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.HashTable<string,string> header_parse_param_list (string header);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.SList<string> header_parse_quality_list (string header, out GLib.SList<string> unacceptable);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.HashTable<string,string> header_parse_semi_param_list (string header);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static bool headers_parse (string str, int len, Soup.MessageHeaders dest);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static uint headers_parse_request (string str, int len, Soup.MessageHeaders req_headers, out string req_method, out string req_path, out Soup.HTTPVersion ver);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static bool headers_parse_response (string str, int len, Soup.MessageHeaders headers, out Soup.HTTPVersion ver, out uint status_code, out string reason_phrase);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static bool headers_parse_status_line (string status_line, out Soup.HTTPVersion ver, out uint status_code, out string reason_phrase);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.Quark http_error_quark ();
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "SSLError.quark", since = "vala-0.14")]
	public static GLib.Quark ssl_error_quark ();
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static unowned string status_get_phrase (uint status_code);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static uint status_proxify (uint status_code);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static bool str_case_equal (void* v1, void* v2);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static uint str_case_hash (void* key);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static void value_array_append (GLib.ValueArray array, GLib.Type type, ...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static void value_array_append_vals (GLib.ValueArray array, ...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.ValueArray value_array_from_args (va_list args);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static bool value_array_get_nth (GLib.ValueArray array, uint index_, GLib.Type type, ...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static void value_array_insert (GLib.ValueArray array, uint index_, GLib.Type type, ...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.ValueArray value_array_new ();
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.ValueArray value_array_new_with_vals (...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static bool value_array_to_args (GLib.ValueArray array, va_list args);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static void value_hash_insert (GLib.HashTable<string,GLib.Value?> hash, string key, GLib.Type type, ...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static void value_hash_insert_vals (GLib.HashTable<string,GLib.Value?> hash, ...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static void value_hash_insert_value (GLib.HashTable<string,GLib.Value?> hash, string key, GLib.Value value);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static bool value_hash_lookup (GLib.HashTable<string,GLib.Value?> hash, string key, GLib.Type type, ...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static bool value_hash_lookup_vals (GLib.HashTable<string,GLib.Value?> hash, ...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.HashTable<string,GLib.Value?> value_hash_new ();
	[CCode (cheader_filename = "libsoup/soup.h")]
	public static GLib.HashTable<string,GLib.Value?> value_hash_new_with_vals (...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "XMLRPC.build_fault", since = "vala-0.12")]
	[PrintfFormat]
	public static unowned string xmlrpc_build_fault (int fault_code, string fault_format, ...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "XMLRPC.build_method_call", since = "vala-0.12")]
	public static unowned string xmlrpc_build_method_call (string method_name, GLib.Value[] @params);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "XMLRPC.build_method_response", since = "vala-0.12")]
	public static unowned string xmlrpc_build_method_response (GLib.Value value);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "XMLRPC.error_quark", since = "vala-0.12")]
	public static GLib.Quark xmlrpc_error_quark ();
	[CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
	[Deprecated (replacement = "XMLRPC.extract_method_call", since = "vala-0.12")]
	public static bool xmlrpc_extract_method_call (string method_call, int length, out unowned string method_name, ...);
	[CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
	[Deprecated (replacement = "XMLRPC.extract_method_response", since = "vala-0.12")]
	public static bool xmlrpc_extract_method_response (string method_response, int length, ...) throws GLib.Error;
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "XMLRPC.fault_quark", since = "vala-0.12")]
	public static GLib.Quark xmlrpc_fault_quark ();
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "XMLRPC.parse_method_call", since = "vala-0.12")]
	public static bool xmlrpc_parse_method_call (string method_call, int length, out unowned string method_name, out unowned GLib.ValueArray @params);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "XMLRPC.parse_method_response", since = "vala-0.12")]
	public static bool xmlrpc_parse_method_response (string method_response, int length, GLib.Value value) throws GLib.Error;
	[CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
	[Deprecated (replacement = "XMLRPC.request_new", since = "vala-0.12")]
	public static unowned Soup.Message xmlrpc_request_new (string uri, string method_name, ...);
	[CCode (cheader_filename = "libsoup/soup.h")]
	[Deprecated (replacement = "XMLRPC.set_fault", since = "vala-0.12")]
	[PrintfFormat]
	public static void xmlrpc_set_fault (Soup.Message msg, int fault_code, string fault_format, ...);
	[CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")]
	[Deprecated (replacement = "XMLRPC.set_response", since = "vala-0.12")]
	public static void xmlrpc_set_response (Soup.Message msg, ...);
}