diff options
Diffstat (limited to 'bindings/lazsoup2_4.pas')
| -rw-r--r-- | bindings/lazsoup2_4.pas | 3688 |
1 files changed, 3688 insertions, 0 deletions
diff --git a/bindings/lazsoup2_4.pas b/bindings/lazsoup2_4.pas new file mode 100644 index 0000000..95e8584 --- /dev/null +++ b/bindings/lazsoup2_4.pas @@ -0,0 +1,3688 @@ +{ This is an autogenerated unit using gobject introspection (gir2pascal). Do not Edit. } +unit LazSoup2_4; + +{$MODE OBJFPC}{$H+} + +{$PACKRECORDS C} +{$MODESWITCH DUPLICATELOCALS+} + +{$LINKLIB libsoup-2.4.so.1} +interface +uses + CTypes, LazGio2, LazGLib2, LazGObject2; + +const + Soup2_4_library = 'libsoup-2.4.so.1'; + + SOUP_ADDRESS_ANY_PORT = 0; + SOUP_ADDRESS_FAMILY = 'family'; + SOUP_ADDRESS_NAME = 'name'; + SOUP_ADDRESS_PHYSICAL = 'physical'; + SOUP_ADDRESS_PORT = 'port'; + SOUP_ADDRESS_PROTOCOL = 'protocol'; + SOUP_ADDRESS_SOCKADDR = 'sockaddr'; + SOUP_AUTH_DOMAIN_ADD_PATH = 'add-path'; + SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK = 'auth-callback'; + SOUP_AUTH_DOMAIN_BASIC_AUTH_DATA = 'auth-data'; + SOUP_AUTH_DOMAIN_BASIC_H = 1; + SOUP_AUTH_DOMAIN_DIGEST_AUTH_CALLBACK = 'auth-callback'; + SOUP_AUTH_DOMAIN_DIGEST_AUTH_DATA = 'auth-data'; + SOUP_AUTH_DOMAIN_DIGEST_H = 1; + SOUP_AUTH_DOMAIN_FILTER = 'filter'; + SOUP_AUTH_DOMAIN_FILTER_DATA = 'filter-data'; + SOUP_AUTH_DOMAIN_GENERIC_AUTH_CALLBACK = 'generic-auth-callback'; + SOUP_AUTH_DOMAIN_GENERIC_AUTH_DATA = 'generic-auth-data'; + SOUP_AUTH_DOMAIN_H = 1; + SOUP_AUTH_DOMAIN_PROXY = 'proxy'; + SOUP_AUTH_DOMAIN_REALM = 'realm'; + SOUP_AUTH_DOMAIN_REMOVE_PATH = 'remove-path'; + SOUP_AUTH_H = 1; + SOUP_AUTH_HOST = 'host'; + SOUP_AUTH_IS_AUTHENTICATED = 'is-authenticated'; + SOUP_AUTH_IS_FOR_PROXY = 'is-for-proxy'; + SOUP_AUTH_MANAGER_H = 1; + SOUP_AUTH_REALM = 'realm'; + SOUP_AUTH_SCHEME_NAME = 'scheme-name'; + SOUP_CACHE_H = 1; + SOUP_CHAR_HTTP_CTL = 16; + SOUP_CHAR_HTTP_SEPARATOR = 8; + SOUP_CHAR_URI_GEN_DELIMS = 2; + SOUP_CHAR_URI_PERCENT_ENCODED = 1; + SOUP_CHAR_URI_SUB_DELIMS = 4; + SOUP_CONTENT_DECODER_H = 1; + SOUP_CONTENT_SNIFFER_H = 1; + SOUP_COOKIE_H = 1; + SOUP_COOKIE_JAR_ACCEPT_POLICY = 'accept-policy'; + SOUP_COOKIE_JAR_DB_FILENAME = 'filename'; + SOUP_COOKIE_JAR_DB_H = 1; + SOUP_COOKIE_JAR_H = 1; + SOUP_COOKIE_JAR_READ_ONLY = 'read-only'; + SOUP_COOKIE_JAR_TEXT_FILENAME = 'filename'; + SOUP_COOKIE_JAR_TEXT_H = 1; + SOUP_COOKIE_MAX_AGE_ONE_DAY = 0; + SOUP_COOKIE_MAX_AGE_ONE_HOUR = 3600; + SOUP_COOKIE_MAX_AGE_ONE_WEEK = 0; + SOUP_COOKIE_MAX_AGE_ONE_YEAR = 0; + SOUP_DATE_H = 1; + SOUP_FORM_H = 1; + SOUP_FORM_MIME_TYPE_MULTIPART = 'multipart/form-data'; + SOUP_FORM_MIME_TYPE_URLENCODED = 'application/x-www-form-urlencoded'; + SOUP_HEADERS_H = 1; + SOUP_LOGGER_H = 1; + SOUP_MESSAGE_BODY_H = 1; + SOUP_MESSAGE_FIRST_PARTY = 'first-party'; + SOUP_MESSAGE_FLAGS = 'flags'; + SOUP_MESSAGE_H = 1; + SOUP_MESSAGE_HEADERS_H = 1; + SOUP_MESSAGE_HTTP_VERSION = 'http-version'; + SOUP_MESSAGE_METHOD = 'method'; + SOUP_MESSAGE_REASON_PHRASE = 'reason-phrase'; + SOUP_MESSAGE_REQUEST_BODY = 'request-body'; + SOUP_MESSAGE_REQUEST_HEADERS = 'request-headers'; + SOUP_MESSAGE_RESPONSE_BODY = 'response-body'; + SOUP_MESSAGE_RESPONSE_HEADERS = 'response-headers'; + SOUP_MESSAGE_SERVER_SIDE = 'server-side'; + SOUP_MESSAGE_STATUS_CODE = 'status-code'; + SOUP_MESSAGE_TLS_CERTIFICATE = 'tls-certificate'; + SOUP_MESSAGE_TLS_ERRORS = 'tls-errors'; + SOUP_MESSAGE_URI = 'uri'; + SOUP_METHOD_H = 1; + SOUP_MISC_H = 1; + SOUP_MULTIPART_H = 1; + SOUP_MULTIPART_INPUT_STREAM_H = 1; + SOUP_PASSWORD_MANAGER_H = 1; + SOUP_PROXY_RESOLVER_DEFAULT_H = 1; + SOUP_PROXY_URI_RESOLVER_H = 1; + SOUP_REQUESTER_H = 1; + SOUP_REQUEST_DATA_H = 1; + SOUP_REQUEST_FILE_H = 1; + SOUP_REQUEST_H = 1; + SOUP_REQUEST_HTTP_H = 1; + SOUP_REQUEST_SESSION = 'session'; + SOUP_REQUEST_URI = 'uri'; + SOUP_SERVER_ASYNC_CONTEXT = 'async-context'; + SOUP_SERVER_H = 1; + SOUP_SERVER_INTERFACE = 'interface'; + SOUP_SERVER_PORT = 'port'; + SOUP_SERVER_RAW_PATHS = 'raw-paths'; + SOUP_SERVER_SERVER_HEADER = 'server-header'; + SOUP_SERVER_SSL_CERT_FILE = 'ssl-cert-file'; + SOUP_SERVER_SSL_KEY_FILE = 'ssl-key-file'; + SOUP_SERVER_TLS_CERTIFICATE = 'tls-certificate'; + SOUP_SESSION_ACCEPT_LANGUAGE = 'accept-language'; + SOUP_SESSION_ACCEPT_LANGUAGE_AUTO = 'accept-language-auto'; + SOUP_SESSION_ADD_FEATURE = 'add-feature'; + SOUP_SESSION_ADD_FEATURE_BY_TYPE = 'add-feature-by-type'; + SOUP_SESSION_ASYNC_CONTEXT = 'async-context'; + SOUP_SESSION_ASYNC_H = 1; + SOUP_SESSION_FEATURE_H = 1; + SOUP_SESSION_H = 1; + SOUP_SESSION_HTTPS_ALIASES = 'https-aliases'; + SOUP_SESSION_HTTP_ALIASES = 'http-aliases'; + SOUP_SESSION_IDLE_TIMEOUT = 'idle-timeout'; + SOUP_SESSION_LOCAL_ADDRESS = 'local-address'; + SOUP_SESSION_MAX_CONNS = 'max-conns'; + SOUP_SESSION_MAX_CONNS_PER_HOST = 'max-conns-per-host'; + SOUP_SESSION_PROXY_RESOLVER = 'proxy-resolver'; + SOUP_SESSION_PROXY_URI = 'proxy-uri'; + SOUP_SESSION_REMOVE_FEATURE_BY_TYPE = 'remove-feature-by-type'; + SOUP_SESSION_SSL_CA_FILE = 'ssl-ca-file'; + SOUP_SESSION_SSL_STRICT = 'ssl-strict'; + SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE = 'ssl-use-system-ca-file'; + SOUP_SESSION_SYNC_H = 1; + SOUP_SESSION_TIMEOUT = 'timeout'; + SOUP_SESSION_TLS_DATABASE = 'tls-database'; + SOUP_SESSION_USER_AGENT = 'user-agent'; + SOUP_SESSION_USE_NTLM = 'use-ntlm'; + SOUP_SESSION_USE_THREAD_CONTEXT = 'use-thread-context'; + SOUP_SOCKET_ASYNC_CONTEXT = 'async-context'; + SOUP_SOCKET_FLAG_NONBLOCKING = 'non-blocking'; + SOUP_SOCKET_H = 1; + SOUP_SOCKET_IS_SERVER = 'is-server'; + SOUP_SOCKET_LOCAL_ADDRESS = 'local-address'; + SOUP_SOCKET_REMOTE_ADDRESS = 'remote-address'; + SOUP_SOCKET_SSL_CREDENTIALS = 'ssl-creds'; + SOUP_SOCKET_SSL_FALLBACK = 'ssl-fallback'; + SOUP_SOCKET_SSL_STRICT = 'ssl-strict'; + SOUP_SOCKET_TIMEOUT = 'timeout'; + SOUP_SOCKET_TLS_CERTIFICATE = 'tls-certificate'; + SOUP_SOCKET_TLS_ERRORS = 'tls-errors'; + SOUP_SOCKET_TRUSTED_CERTIFICATE = 'trusted-certificate'; + SOUP_SOCKET_USE_THREAD_CONTEXT = 'use-thread-context'; + SOUP_STATUS_H = 1; + SOUP_TYPES_H = 1; + SOUP_URI_H = 1; + SOUP_VALUE_UTILS_H = 1; + SOUP_XMLRPC_H = 1; + +type + TSoupAddressFamily = Integer; +const + { SoupAddressFamily } + SOUP_ADDRESS_FAMILY_INVALID: TSoupAddressFamily = -1; + SOUP_ADDRESS_FAMILY_IPV4: TSoupAddressFamily = 2; + SOUP_ADDRESS_FAMILY_IPV6: TSoupAddressFamily = 10; + +type + TSoupMessageFlags = Integer; +const + { SoupMessageFlags } + SOUP_MESSAGE_NO_REDIRECT: TSoupMessageFlags = 2; + SOUP_MESSAGE_CAN_REBUILD: TSoupMessageFlags = 4; + SOUP_MESSAGE_OVERWRITE_CHUNKS: TSoupMessageFlags = 8; + SOUP_MESSAGE_CONTENT_DECODED: TSoupMessageFlags = 16; + SOUP_MESSAGE_CERTIFICATE_TRUSTED: TSoupMessageFlags = 32; + SOUP_MESSAGE_NEW_CONNECTION: TSoupMessageFlags = 64; + SOUP_MESSAGE_IDEMPOTENT: TSoupMessageFlags = 128; + +type + TSoupHTTPVersion = Integer; +const + { SoupHTTPVersion } + SOUP_HTTP_1_0: TSoupHTTPVersion = 0; + SOUP_HTTP_1_1: TSoupHTTPVersion = 1; + +type + TSoupMemoryUse = Integer; +const + { SoupMemoryUse } + SOUP_MEMORY_STATIC: TSoupMemoryUse = 0; + SOUP_MEMORY_TAKE: TSoupMemoryUse = 1; + SOUP_MEMORY_COPY: TSoupMemoryUse = 2; + SOUP_MEMORY_TEMPORARY: TSoupMemoryUse = 3; + +type + TSoupCacheType = Integer; +const + { SoupCacheType } + SOUP_CACHE_SINGLE_USER: TSoupCacheType = 0; + SOUP_CACHE_SHARED: TSoupCacheType = 1; + +type + TSoupCacheability = Integer; +const + { SoupCacheability } + SOUP_CACHE_CACHEABLE: TSoupCacheability = 1; + SOUP_CACHE_UNCACHEABLE: TSoupCacheability = 2; + SOUP_CACHE_INVALIDATES: TSoupCacheability = 4; + SOUP_CACHE_VALIDATES: TSoupCacheability = 8; + +type + TSoupCacheResponse = Integer; +const + { SoupCacheResponse } + SOUP_CACHE_RESPONSE_FRESH: TSoupCacheResponse = 0; + SOUP_CACHE_RESPONSE_NEEDS_VALIDATION: TSoupCacheResponse = 1; + SOUP_CACHE_RESPONSE_STALE: TSoupCacheResponse = 2; + +type + TSoupConnectionState = Integer; +const + { SoupConnectionState } + SOUP_CONNECTION_NEW: TSoupConnectionState = 0; + SOUP_CONNECTION_CONNECTING: TSoupConnectionState = 1; + SOUP_CONNECTION_IDLE: TSoupConnectionState = 2; + SOUP_CONNECTION_IN_USE: TSoupConnectionState = 3; + SOUP_CONNECTION_REMOTE_DISCONNECTED: TSoupConnectionState = 4; + SOUP_CONNECTION_DISCONNECTED: TSoupConnectionState = 5; + +type + TSoupDateFormat = Integer; +const + { SoupDateFormat } + SOUP_DATE_HTTP: TSoupDateFormat = 1; + SOUP_DATE_COOKIE: TSoupDateFormat = 2; + SOUP_DATE_RFC2822: TSoupDateFormat = 3; + SOUP_DATE_ISO8601_COMPACT: TSoupDateFormat = 4; + SOUP_DATE_ISO8601_FULL: TSoupDateFormat = 5; + SOUP_DATE_ISO8601: TSoupDateFormat = 5; + SOUP_DATE_ISO8601_XMLRPC: TSoupDateFormat = 6; + +type + TSoupCookieJarAcceptPolicy = Integer; +const + { SoupCookieJarAcceptPolicy } + SOUP_COOKIE_JAR_ACCEPT_ALWAYS: TSoupCookieJarAcceptPolicy = 0; + SOUP_COOKIE_JAR_ACCEPT_NEVER: TSoupCookieJarAcceptPolicy = 1; + SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY: TSoupCookieJarAcceptPolicy = 2; + +type + TSoupEncoding = Integer; +const + { SoupEncoding } + SOUP_ENCODING_UNRECOGNIZED: TSoupEncoding = 0; + SOUP_ENCODING_NONE: TSoupEncoding = 1; + SOUP_ENCODING_CONTENT_LENGTH: TSoupEncoding = 2; + SOUP_ENCODING_EOF: TSoupEncoding = 3; + SOUP_ENCODING_CHUNKED: TSoupEncoding = 4; + SOUP_ENCODING_BYTERANGES: TSoupEncoding = 5; + +type + TSoupExpectation = Integer; +const + { SoupExpectation } + SOUP_EXPECTATION_UNRECOGNIZED: TSoupExpectation = 1; + SOUP_EXPECTATION_CONTINUE: TSoupExpectation = 2; + +type + TSoupKnownStatusCode = Integer; +const + { SoupKnownStatusCode } + SOUP_STATUS_NONE: TSoupKnownStatusCode = 0; + SOUP_STATUS_CANCELLED: TSoupKnownStatusCode = 1; + SOUP_STATUS_CANT_RESOLVE: TSoupKnownStatusCode = 2; + SOUP_STATUS_CANT_RESOLVE_PROXY: TSoupKnownStatusCode = 3; + SOUP_STATUS_CANT_CONNECT: TSoupKnownStatusCode = 4; + SOUP_STATUS_CANT_CONNECT_PROXY: TSoupKnownStatusCode = 5; + SOUP_STATUS_SSL_FAILED: TSoupKnownStatusCode = 6; + SOUP_STATUS_IO_ERROR: TSoupKnownStatusCode = 7; + SOUP_STATUS_MALFORMED: TSoupKnownStatusCode = 8; + SOUP_STATUS_TRY_AGAIN: TSoupKnownStatusCode = 9; + SOUP_STATUS_TOO_MANY_REDIRECTS: TSoupKnownStatusCode = 10; + SOUP_STATUS_TLS_FAILED: TSoupKnownStatusCode = 11; + SOUP_STATUS_CONTINUE: TSoupKnownStatusCode = 100; + SOUP_STATUS_SWITCHING_PROTOCOLS: TSoupKnownStatusCode = 101; + SOUP_STATUS_PROCESSING: TSoupKnownStatusCode = 102; + SOUP_STATUS_OK: TSoupKnownStatusCode = 200; + SOUP_STATUS_CREATED: TSoupKnownStatusCode = 201; + SOUP_STATUS_ACCEPTED: TSoupKnownStatusCode = 202; + SOUP_STATUS_NON_AUTHORITATIVE: TSoupKnownStatusCode = 203; + SOUP_STATUS_NO_CONTENT: TSoupKnownStatusCode = 204; + SOUP_STATUS_RESET_CONTENT: TSoupKnownStatusCode = 205; + SOUP_STATUS_PARTIAL_CONTENT: TSoupKnownStatusCode = 206; + SOUP_STATUS_MULTI_STATUS: TSoupKnownStatusCode = 207; + SOUP_STATUS_MULTIPLE_CHOICES: TSoupKnownStatusCode = 300; + SOUP_STATUS_MOVED_PERMANENTLY: TSoupKnownStatusCode = 301; + SOUP_STATUS_FOUND: TSoupKnownStatusCode = 302; + SOUP_STATUS_MOVED_TEMPORARILY: TSoupKnownStatusCode = 302; + SOUP_STATUS_SEE_OTHER: TSoupKnownStatusCode = 303; + SOUP_STATUS_NOT_MODIFIED: TSoupKnownStatusCode = 304; + SOUP_STATUS_USE_PROXY: TSoupKnownStatusCode = 305; + SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL: TSoupKnownStatusCode = 306; + SOUP_STATUS_TEMPORARY_REDIRECT: TSoupKnownStatusCode = 307; + SOUP_STATUS_BAD_REQUEST: TSoupKnownStatusCode = 400; + SOUP_STATUS_UNAUTHORIZED: TSoupKnownStatusCode = 401; + SOUP_STATUS_PAYMENT_REQUIRED: TSoupKnownStatusCode = 402; + SOUP_STATUS_FORBIDDEN: TSoupKnownStatusCode = 403; + SOUP_STATUS_NOT_FOUND: TSoupKnownStatusCode = 404; + SOUP_STATUS_METHOD_NOT_ALLOWED: TSoupKnownStatusCode = 405; + SOUP_STATUS_NOT_ACCEPTABLE: TSoupKnownStatusCode = 406; + SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED: TSoupKnownStatusCode = 407; + SOUP_STATUS_PROXY_UNAUTHORIZED: TSoupKnownStatusCode = 407; + SOUP_STATUS_REQUEST_TIMEOUT: TSoupKnownStatusCode = 408; + SOUP_STATUS_CONFLICT: TSoupKnownStatusCode = 409; + SOUP_STATUS_GONE: TSoupKnownStatusCode = 410; + SOUP_STATUS_LENGTH_REQUIRED: TSoupKnownStatusCode = 411; + SOUP_STATUS_PRECONDITION_FAILED: TSoupKnownStatusCode = 412; + SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE: TSoupKnownStatusCode = 413; + SOUP_STATUS_REQUEST_URI_TOO_LONG: TSoupKnownStatusCode = 414; + SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE: TSoupKnownStatusCode = 415; + SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE: TSoupKnownStatusCode = 416; + SOUP_STATUS_INVALID_RANGE: TSoupKnownStatusCode = 416; + SOUP_STATUS_EXPECTATION_FAILED: TSoupKnownStatusCode = 417; + SOUP_STATUS_UNPROCESSABLE_ENTITY: TSoupKnownStatusCode = 422; + SOUP_STATUS_LOCKED: TSoupKnownStatusCode = 423; + SOUP_STATUS_FAILED_DEPENDENCY: TSoupKnownStatusCode = 424; + SOUP_STATUS_INTERNAL_SERVER_ERROR: TSoupKnownStatusCode = 500; + SOUP_STATUS_NOT_IMPLEMENTED: TSoupKnownStatusCode = 501; + SOUP_STATUS_BAD_GATEWAY: TSoupKnownStatusCode = 502; + SOUP_STATUS_SERVICE_UNAVAILABLE: TSoupKnownStatusCode = 503; + SOUP_STATUS_GATEWAY_TIMEOUT: TSoupKnownStatusCode = 504; + SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED: TSoupKnownStatusCode = 505; + SOUP_STATUS_INSUFFICIENT_STORAGE: TSoupKnownStatusCode = 507; + SOUP_STATUS_NOT_EXTENDED: TSoupKnownStatusCode = 510; + +type + TSoupLoggerLogLevel = Integer; +const + { SoupLoggerLogLevel } + SOUP_LOGGER_LOG_NONE: TSoupLoggerLogLevel = 0; + SOUP_LOGGER_LOG_MINIMAL: TSoupLoggerLogLevel = 1; + SOUP_LOGGER_LOG_HEADERS: TSoupLoggerLogLevel = 2; + SOUP_LOGGER_LOG_BODY: TSoupLoggerLogLevel = 3; + +type + TSoupMessageHeadersType = Integer; +const + { SoupMessageHeadersType } + SOUP_MESSAGE_HEADERS_REQUEST: TSoupMessageHeadersType = 0; + SOUP_MESSAGE_HEADERS_RESPONSE: TSoupMessageHeadersType = 1; + SOUP_MESSAGE_HEADERS_MULTIPART: TSoupMessageHeadersType = 2; + +type + TSoupRequestError = Integer; +const + { SoupRequestError } + SOUP_REQUEST_ERROR_BAD_URI: TSoupRequestError = 0; + SOUP_REQUEST_ERROR_UNSUPPORTED_URI_SCHEME: TSoupRequestError = 1; + SOUP_REQUEST_ERROR_PARSING: TSoupRequestError = 2; + SOUP_REQUEST_ERROR_ENCODING: TSoupRequestError = 3; + +type + TSoupRequesterError = Integer; +const + { SoupRequesterError } + SOUP_REQUESTER_ERROR_BAD_URI: TSoupRequesterError = 0; + SOUP_REQUESTER_ERROR_UNSUPPORTED_URI_SCHEME: TSoupRequesterError = 1; + +type + TSoupSocketIOStatus = Integer; +const + { SoupSocketIOStatus } + SOUP_SOCKET_OK: TSoupSocketIOStatus = 0; + SOUP_SOCKET_WOULD_BLOCK: TSoupSocketIOStatus = 1; + SOUP_SOCKET_EOF: TSoupSocketIOStatus = 2; + SOUP_SOCKET_ERROR: TSoupSocketIOStatus = 3; + +type + TSoupTLDError = Integer; +const + { SoupTLDError } + SOUP_TLD_ERROR_INVALID_HOSTNAME: TSoupTLDError = 0; + SOUP_TLD_ERROR_IS_IP_ADDRESS: TSoupTLDError = 1; + SOUP_TLD_ERROR_NOT_ENOUGH_DOMAINS: TSoupTLDError = 2; + SOUP_TLD_ERROR_NO_BASE_DOMAIN: TSoupTLDError = 3; + +type + TSoupXMLRPCError = Integer; +const + { SoupXMLRPCError } + SOUP_XMLRPC_ERROR_ARGUMENTS: TSoupXMLRPCError = 0; + SOUP_XMLRPC_ERROR_RETVAL: TSoupXMLRPCError = 1; + +type + TSoupXMLRPCFault = Integer; +const + { SoupXMLRPCFault } + SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED: TSoupXMLRPCFault = -32700; + SOUP_XMLRPC_FAULT_PARSE_ERROR_UNSUPPORTED_ENCODING: TSoupXMLRPCFault = -32701; + SOUP_XMLRPC_FAULT_PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING: TSoupXMLRPCFault = -32702; + SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_XML_RPC: TSoupXMLRPCFault = -32600; + SOUP_XMLRPC_FAULT_SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND: TSoupXMLRPCFault = -32601; + SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS: TSoupXMLRPCFault = -32602; + SOUP_XMLRPC_FAULT_SERVER_ERROR_INTERNAL_XML_RPC_ERROR: TSoupXMLRPCFault = -32603; + SOUP_XMLRPC_FAULT_APPLICATION_ERROR: TSoupXMLRPCFault = -32500; + SOUP_XMLRPC_FAULT_SYSTEM_ERROR: TSoupXMLRPCFault = -32400; + SOUP_XMLRPC_FAULT_TRANSPORT_ERROR: TSoupXMLRPCFault = -32300; +type + + PPSoupAddress = ^PSoupAddress; + PSoupAddress = ^TSoupAddress; + + PPSoupAddressFamily = ^PSoupAddressFamily; + PSoupAddressFamily = ^TSoupAddressFamily; + + PPSoupAddressCallback = ^PSoupAddressCallback; + PSoupAddressCallback = ^TSoupAddressCallback; + TSoupAddressCallback = procedure(addr: PSoupAddress; status: guint; user_data: gpointer); cdecl; + TSoupAddress = object(TGObject) + function new(name: Pgchar; port: guint): PSoupAddress; cdecl; inline; static; + function new_any(family: TSoupAddressFamily; port: guint): PSoupAddress; cdecl; inline; static; + function new_from_sockaddr(sa: Pgpointer; len: gint): PSoupAddress; cdecl; inline; static; + function equal_by_ip(addr2: PSoupAddress): gboolean; cdecl; inline; + function equal_by_name(addr2: PSoupAddress): gboolean; cdecl; inline; + function get_gsockaddr: PGSocketAddress; cdecl; inline; + function get_name: Pgchar; cdecl; inline; + function get_physical: Pgchar; cdecl; inline; + function get_port: guint; cdecl; inline; + function get_sockaddr(len: Pgint): Pgpointer; cdecl; inline; + function hash_by_ip: guint; cdecl; inline; + function hash_by_name: guint; cdecl; inline; + function is_resolved: gboolean; cdecl; inline; + procedure resolve_async(async_context: PGMainContext; cancellable: PGCancellable; callback: TSoupAddressCallback; user_data: gpointer); cdecl; inline; + function resolve_sync(cancellable: PGCancellable): guint; cdecl; inline; + //property family: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_family { property is writeable but setter not declared } ; + property name: Pgchar read get_name { property is writeable but setter not declared } ; + property physical: Pgchar read get_physical ; + property port: guint read get_port { property is writeable but setter not declared } ; + //property protocol: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_protocol { property is writeable but setter not declared } ; + //property sockaddr: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_sockaddr { property is writeable but setter not declared } ; + end; + + PPSoupAddressClass = ^PSoupAddressClass; + PSoupAddressClass = ^TSoupAddressClass; + TSoupAddressClass = object + parent_class: TGObjectClass; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupAuth = ^PSoupAuth; + PSoupAuth = ^TSoupAuth; + + PPSoupMessage = ^PSoupMessage; + PSoupMessage = ^TSoupMessage; + + PPSoupURI = ^PSoupURI; + PSoupURI = ^TSoupURI; + TSoupAuth = object(TGObject) + realm1: Pgchar; + function new(type_: TGType; msg: PSoupMessage; auth_header: Pgchar): PSoupAuth; cdecl; inline; static; + procedure authenticate(username: Pgchar; password: Pgchar); cdecl; inline; + procedure free_protection_space(space: PGSList); cdecl; inline; + function get_authorization(msg: PSoupMessage): Pgchar; cdecl; inline; + function get_host: Pgchar; cdecl; inline; + function get_info: Pgchar; cdecl; inline; + function get_protection_space(source_uri: PSoupURI): PGSList; cdecl; inline; + function get_realm: Pgchar; cdecl; inline; + function get_saved_password(user: Pgchar): Pgchar; cdecl; inline; + function get_saved_users: PGSList; cdecl; inline; + function get_scheme_name: Pgchar; cdecl; inline; + procedure has_saved_password(username: Pgchar; password: Pgchar); cdecl; inline; + function is_authenticated: gboolean; cdecl; inline; + function is_for_proxy: gboolean; cdecl; inline; + function is_ready(msg: PSoupMessage): gboolean; cdecl; inline; + procedure save_password(username: Pgchar; password: Pgchar); cdecl; inline; + function update(msg: PSoupMessage; auth_header: Pgchar): gboolean; cdecl; inline; + property host: Pgchar read get_host { property is writeable but setter not declared } ; + //property is_authenticated1: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_is_authenticated ; + //property is_for_proxy1: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_is_for_proxy { property is writeable but setter not declared } ; + property realm: Pgchar read get_realm { property is writeable but setter not declared } ; + property scheme_name: Pgchar read get_scheme_name ; + end; + + PPSoupMessageFlags = ^PSoupMessageFlags; + PSoupMessageFlags = ^TSoupMessageFlags; + + PPSoupHTTPVersion = ^PSoupHTTPVersion; + PSoupHTTPVersion = ^TSoupHTTPVersion; + + PPSoupRequest = ^PSoupRequest; + PSoupRequest = ^TSoupRequest; + + PPSoupBuffer = ^PSoupBuffer; + PSoupBuffer = ^TSoupBuffer; + + PPSoupMemoryUse = ^PSoupMemoryUse; + PSoupMemoryUse = ^TSoupMemoryUse; + + PPSoupMessageBody = ^PSoupMessageBody; + PSoupMessageBody = ^TSoupMessageBody; + + PPSoupMessageHeaders = ^PSoupMessageHeaders; + PSoupMessageHeaders = ^TSoupMessageHeaders; + TSoupMessage = object(TGObject) + method1: Pgchar; + status_code1: guint; + reason_phrase1: Pgchar; + request_body1: PSoupMessageBody; + request_headers1: PSoupMessageHeaders; + response_body1: PSoupMessageBody; + response_headers1: PSoupMessageHeaders; + function new(method: Pgchar; uri_string: Pgchar): PSoupMessage; cdecl; inline; static; + function new_from_uri(method: Pgchar; uri: PSoupURI): PSoupMessage; cdecl; inline; static; + function add_header_handler(signal: Pgchar; header: Pgchar; callback: TGCallback; user_data: gpointer): guint; cdecl; inline; + function add_status_code_handler(signal: Pgchar; status_code: guint; callback: TGCallback; user_data: gpointer): guint; cdecl; inline; + procedure content_sniffed(content_type: Pgchar; params: PGHashTable); cdecl; inline; + procedure disable_feature(feature_type: TGType); cdecl; inline; + procedure finished; cdecl; inline; + function get_address: PSoupAddress; cdecl; inline; + function get_first_party: PSoupURI; cdecl; inline; + function get_flags: TSoupMessageFlags; cdecl; inline; + function get_http_version: TSoupHTTPVersion; cdecl; inline; + function get_https_status(certificate: PPGTlsCertificate; errors: PGTlsCertificateFlags): gboolean; cdecl; inline; + function get_soup_request: PSoupRequest; cdecl; inline; + function get_uri: PSoupURI; cdecl; inline; + procedure got_body; cdecl; inline; + procedure got_chunk(chunk: PSoupBuffer); cdecl; inline; + procedure got_headers; cdecl; inline; + procedure got_informational; cdecl; inline; + function is_keepalive: gboolean; cdecl; inline; + procedure restarted; cdecl; inline; + procedure set_first_party(first_party: PSoupURI); cdecl; inline; + procedure set_flags(flags: TSoupMessageFlags); cdecl; inline; + procedure set_http_version(version: TSoupHTTPVersion); cdecl; inline; + procedure set_redirect(status_code: guint; redirect_uri: Pgchar); cdecl; inline; + procedure set_request(content_type: Pgchar; req_use: TSoupMemoryUse; req_body: Pgchar; req_length: gsize); cdecl; inline; + procedure set_response(content_type: Pgchar; resp_use: TSoupMemoryUse; resp_body: Pgchar; resp_length: gsize); cdecl; inline; + procedure set_status(status_code: guint); cdecl; inline; + procedure set_status_full(status_code: guint; reason_phrase: Pgchar); cdecl; inline; + procedure set_uri(uri: PSoupURI); cdecl; inline; + procedure wrote_body; cdecl; inline; + procedure wrote_body_data(chunk: PSoupBuffer); cdecl; inline; + procedure wrote_chunk; cdecl; inline; + procedure wrote_headers; cdecl; inline; + procedure wrote_informational; cdecl; inline; + property first_party: PSoupURI read get_first_party write set_first_party; + property flags: TSoupMessageFlags read get_flags write set_flags; + property http_version: TSoupHTTPVersion read get_http_version write set_http_version; + //property method: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_method { property is writeable but setter not declared } ; + //property reason_phrase: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_reason_phrase { property is writeable but setter not declared } ; + //property request_body: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_request_body ; + //property request_headers: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_request_headers ; + //property response_body: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_response_body ; + //property response_headers: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_response_headers ; + //property server_side: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_server_side { property is writeable but setter not declared } ; + //property status_code: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_status_code { property is writeable but setter not declared } ; + //property tls_certificate: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_tls_certificate { property is writeable but setter not declared } ; + //property tls_errors: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_tls_errors { property is writeable but setter not declared } ; + property uri: PSoupURI read get_uri write set_uri; + end; + TSoupURI = object + scheme: Pgchar; + user: Pgchar; + password: Pgchar; + host: Pgchar; + port: guint; + path: Pgchar; + query: Pgchar; + fragment: Pgchar; + function new(uri_string: Pgchar): PSoupURI; cdecl; inline; static; + function copy: PSoupURI; cdecl; inline; + function copy_host: PSoupURI; cdecl; inline; + function equal(uri2: PSoupURI): gboolean; cdecl; inline; + procedure free; cdecl; inline; + function get_fragment: Pgchar; cdecl; inline; + function get_host: Pgchar; cdecl; inline; + function get_password: Pgchar; cdecl; inline; + function get_path: Pgchar; cdecl; inline; + function get_port: guint; cdecl; inline; + function get_query: Pgchar; cdecl; inline; + function get_scheme: Pgchar; cdecl; inline; + function get_user: Pgchar; cdecl; inline; + function host_equal(v2: PSoupURI): gboolean; cdecl; inline; + function host_hash: guint; cdecl; inline; + function new_with_base(uri_string: Pgchar): PSoupURI; cdecl; inline; + procedure set_fragment(fragment: Pgchar); cdecl; inline; + procedure set_host(host: Pgchar); cdecl; inline; + procedure set_password(password: Pgchar); cdecl; inline; + procedure set_path(path: Pgchar); cdecl; inline; + procedure set_port(port: guint); cdecl; inline; + procedure set_query(query: Pgchar); cdecl; inline; + //procedure set_query_from_fields(first_field: Pgchar; args: array of const); cdecl; inline; + procedure set_query_from_form(form: PGHashTable); cdecl; inline; + procedure set_scheme(scheme: Pgchar); cdecl; inline; + procedure set_user(user: Pgchar); cdecl; inline; + function to_string(just_path_and_query: gboolean): Pgchar; cdecl; inline; + function uses_default_port: gboolean; cdecl; inline; + function decode(part: Pgchar): Pgchar; cdecl; inline; static; + function encode(part: Pgchar; escape_extra: Pgchar): Pgchar; cdecl; inline; static; + function normalize(part: Pgchar; unescape_extra: Pgchar): Pgchar; cdecl; inline; static; + end; + + PPSoupAuthBasic = ^PSoupAuthBasic; + PSoupAuthBasic = ^TSoupAuthBasic; + TSoupAuthBasic = object(TSoupAuth) + end; + + PPSoupAuthClass = ^PSoupAuthClass; + PSoupAuthClass = ^TSoupAuthClass; + TSoupAuthClass = object + parent_class: TGObjectClass; + scheme_name: Pgchar; + strength: guint; + update: function(auth: PSoupAuth; msg: PSoupMessage; auth_header: PGHashTable): gboolean; cdecl; + get_protection_space: function(auth: PSoupAuth; source_uri: PSoupURI): PGSList; cdecl; + authenticate: procedure(auth: PSoupAuth; username: Pgchar; password: Pgchar); cdecl; + is_authenticated: function(auth: PSoupAuth): gboolean; cdecl; + get_authorization: function(auth: PSoupAuth; msg: PSoupMessage): Pgchar; cdecl; + is_ready: function(auth: PSoupAuth; msg: PSoupMessage): gboolean; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupAuthDigest = ^PSoupAuthDigest; + PSoupAuthDigest = ^TSoupAuthDigest; + TSoupAuthDigest = object(TSoupAuth) + end; + + PPSoupAuthDomain = ^PSoupAuthDomain; + PSoupAuthDomain = ^TSoupAuthDomain; + + PPSoupAuthDomainBasicAuthCallback = ^PSoupAuthDomainBasicAuthCallback; + PSoupAuthDomainBasicAuthCallback = ^TSoupAuthDomainBasicAuthCallback; + TSoupAuthDomainBasicAuthCallback = function(domain: PSoupAuthDomain; msg: PSoupMessage; username: Pgchar; password: Pgchar; user_data: gpointer): gboolean; cdecl; + + PPSoupAuthDomainDigestAuthCallback = ^PSoupAuthDomainDigestAuthCallback; + PSoupAuthDomainDigestAuthCallback = ^TSoupAuthDomainDigestAuthCallback; + TSoupAuthDomainDigestAuthCallback = function(domain: PSoupAuthDomain; msg: PSoupMessage; username: Pgchar; user_data: gpointer): Pgchar; cdecl; + + PPSoupAuthDomainFilter = ^PSoupAuthDomainFilter; + PSoupAuthDomainFilter = ^TSoupAuthDomainFilter; + TSoupAuthDomainFilter = function(domain: PSoupAuthDomain; msg: PSoupMessage; user_data: gpointer): gboolean; cdecl; + + PPSoupAuthDomainGenericAuthCallback = ^PSoupAuthDomainGenericAuthCallback; + PSoupAuthDomainGenericAuthCallback = ^TSoupAuthDomainGenericAuthCallback; + TSoupAuthDomainGenericAuthCallback = function(domain: PSoupAuthDomain; msg: PSoupMessage; username: Pgchar; user_data: gpointer): gboolean; cdecl; + TSoupAuthDomain = object(TGObject) + function accepts(msg: PSoupMessage): Pgchar; cdecl; inline; + procedure add_path(path: Pgchar); cdecl; inline; + procedure basic_set_auth_callback(callback: TSoupAuthDomainBasicAuthCallback; user_data: gpointer; dnotify: TGDestroyNotify); cdecl; inline; + procedure challenge(msg: PSoupMessage); cdecl; inline; + function check_password(msg: PSoupMessage; username: Pgchar; password: Pgchar): gboolean; cdecl; inline; + function covers(msg: PSoupMessage): gboolean; cdecl; inline; + procedure digest_set_auth_callback(callback: TSoupAuthDomainDigestAuthCallback; user_data: gpointer; dnotify: TGDestroyNotify); cdecl; inline; + function get_realm: Pgchar; cdecl; inline; + procedure remove_path(path: Pgchar); cdecl; inline; + procedure set_filter(filter: TSoupAuthDomainFilter; filter_data: gpointer; dnotify: TGDestroyNotify); cdecl; inline; + procedure set_generic_auth_callback(auth_callback: TSoupAuthDomainGenericAuthCallback; auth_data: gpointer; dnotify: TGDestroyNotify); cdecl; inline; + function try_generic_auth_callback(msg: PSoupMessage; username: Pgchar): gboolean; cdecl; inline; + //property add_path1: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_add_path { property is writeable but setter not declared } ; + //property filter: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_filter { property is writeable but setter not declared } ; + //property filter_data: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_filter_data { property is writeable but setter not declared } ; + //property generic_auth_callback: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_generic_auth_callback { property is writeable but setter not declared } ; + //property generic_auth_data: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_generic_auth_data { property is writeable but setter not declared } ; + //property proxy: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_proxy { property is writeable but setter not declared } ; + property realm: Pgchar read get_realm { property is writeable but setter not declared } ; + //property remove_path1: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_remove_path { property is writeable but setter not declared } ; + end; + + PPSoupAuthDomainBasic = ^PSoupAuthDomainBasic; + PSoupAuthDomainBasic = ^TSoupAuthDomainBasic; + TSoupAuthDomainBasic = object(TSoupAuthDomain) + //function new(optname1: Pgchar; args: array of const): PSoupAuthDomainBasic; cdecl; inline; static; + //property auth_callback: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_auth_callback { property is writeable but setter not declared } ; + //property auth_data: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_auth_data { property is writeable but setter not declared } ; + end; + + PPSoupAuthDomainClass = ^PSoupAuthDomainClass; + PSoupAuthDomainClass = ^TSoupAuthDomainClass; + TSoupAuthDomainClass = object + parent_class: TGObjectClass; + accepts: function(domain: PSoupAuthDomain; msg: PSoupMessage; header: Pgchar): Pgchar; cdecl; + challenge: function(domain: PSoupAuthDomain; msg: PSoupMessage): Pgchar; cdecl; + check_password: function(domain: PSoupAuthDomain; msg: PSoupMessage; username: Pgchar; password: Pgchar): gboolean; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupAuthDomainBasicClass = ^PSoupAuthDomainBasicClass; + PSoupAuthDomainBasicClass = ^TSoupAuthDomainBasicClass; + TSoupAuthDomainBasicClass = object + parent_class: TSoupAuthDomainClass; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupAuthDomainDigest = ^PSoupAuthDomainDigest; + PSoupAuthDomainDigest = ^TSoupAuthDomainDigest; + TSoupAuthDomainDigest = object(TSoupAuthDomain) + //function new(optname1: Pgchar; args: array of const): PSoupAuthDomainDigest; cdecl; inline; static; + function encode_password(username: Pgchar; realm: Pgchar; password: Pgchar): Pgchar; cdecl; inline; static; + //property auth_callback: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_auth_callback { property is writeable but setter not declared } ; + //property auth_data: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_auth_data { property is writeable but setter not declared } ; + end; + + PPSoupAuthDomainDigestClass = ^PSoupAuthDomainDigestClass; + PSoupAuthDomainDigestClass = ^TSoupAuthDomainDigestClass; + TSoupAuthDomainDigestClass = object + parent_class: TSoupAuthDomainClass; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupSessionFeature = ^PSoupSessionFeature; + PSoupSessionFeature = ^TSoupSessionFeature; + + PPSoupSession = ^PSoupSession; + PSoupSession = ^TSoupSession; + TSoupSessionFeature = object + function add_feature(type_: TGType): gboolean; cdecl; inline; + procedure attach(session: PSoupSession); cdecl; inline; + procedure detach(session: PSoupSession); cdecl; inline; + function has_feature(type_: TGType): gboolean; cdecl; inline; + function remove_feature(type_: TGType): gboolean; cdecl; inline; + end; + + PPSoupAuthManager = ^PSoupAuthManager; + PSoupAuthManager = ^TSoupAuthManager; + + PPSoupAuthManagerPrivate = ^PSoupAuthManagerPrivate; + PSoupAuthManagerPrivate = ^TSoupAuthManagerPrivate; + TSoupAuthManager = object(TGObject) + priv: PSoupAuthManagerPrivate; + procedure use_auth(uri: PSoupURI; auth: PSoupAuth); cdecl; inline; + end; + + TSoupAuthManagerPrivate = record + end; + + + + PPSoupAuthManagerClass = ^PSoupAuthManagerClass; + PSoupAuthManagerClass = ^TSoupAuthManagerClass; + TSoupAuthManagerClass = object + parent_class: TGObjectClass; + authenticate: procedure(manager: PSoupAuthManager; msg: PSoupMessage; auth: PSoupAuth; retrying: gboolean); cdecl; + end; + + PPSoupAuthNTLM = ^PSoupAuthNTLM; + PSoupAuthNTLM = ^TSoupAuthNTLM; + TSoupAuthNTLM = object(TSoupAuth) + end; + TSoupBuffer = object + data: gpointer; + length: gsize; + function new(use: TSoupMemoryUse; data: Pgpointer; length: gsize): PSoupBuffer; cdecl; inline; static; + function new_take(data: Pguint8; length: gsize): PSoupBuffer; cdecl; inline; static; + function new_with_owner(data: Pgpointer; length: gsize; owner: gpointer; owner_dnotify: TGDestroyNotify): PSoupBuffer; cdecl; inline; static; + function copy: PSoupBuffer; cdecl; inline; + procedure free; cdecl; inline; + function get_as_bytes: PGBytes; cdecl; inline; + procedure get_data(data: PPguint8; length: Pgsize); cdecl; inline; + function get_owner: gpointer; cdecl; inline; + function new_subbuffer(offset: gsize; length: gsize): PSoupBuffer; cdecl; inline; + end; + + PPSoupCache = ^PSoupCache; + PSoupCache = ^TSoupCache; + + PPSoupCacheType = ^PSoupCacheType; + PSoupCacheType = ^TSoupCacheType; + + PPSoupCachePrivate = ^PSoupCachePrivate; + PSoupCachePrivate = ^TSoupCachePrivate; + TSoupCache = object(TGObject) + priv: PSoupCachePrivate; + function new(cache_dir: Pgchar; cache_type: TSoupCacheType): PSoupCache; cdecl; inline; static; + procedure clear; cdecl; inline; + procedure dump; cdecl; inline; + procedure flush; cdecl; inline; + function get_max_size: guint; cdecl; inline; + procedure load; cdecl; inline; + procedure set_max_size(max_size: guint); cdecl; inline; + //property cache_dir: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_cache_dir { property is writeable but setter not declared } ; + //property cache_type: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_cache_type { property is writeable but setter not declared } ; + end; + + PPSoupCacheability = ^PSoupCacheability; + PSoupCacheability = ^TSoupCacheability; + + TSoupCachePrivate = record + end; + + + + PPSoupCacheClass = ^PSoupCacheClass; + PSoupCacheClass = ^TSoupCacheClass; + TSoupCacheClass = object + parent_class: TGObjectClass; + get_cacheability: function(cache: PSoupCache; msg: PSoupMessage): TSoupCacheability; cdecl; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + end; + + PPSoupCacheResponse = ^PSoupCacheResponse; + PSoupCacheResponse = ^TSoupCacheResponse; + TSoupChunkAllocator = function(msg: PSoupMessage; max_len: gsize; user_data: gpointer): PSoupBuffer; cdecl; + + PPSoupClientContext = ^PSoupClientContext; + PSoupClientContext = ^TSoupClientContext; + + PPSoupSocket = ^PSoupSocket; + PSoupSocket = ^TSoupSocket; + TSoupClientContext = object + function get_address: PSoupAddress; cdecl; inline; + function get_auth_domain: PSoupAuthDomain; cdecl; inline; + function get_auth_user: Pgchar; cdecl; inline; + function get_host: Pgchar; cdecl; inline; + function get_socket: PSoupSocket; cdecl; inline; + end; + + PPSoupSocketCallback = ^PSoupSocketCallback; + PSoupSocketCallback = ^TSoupSocketCallback; + TSoupSocketCallback = procedure(sock: PSoupSocket; status: guint; user_data: gpointer); cdecl; + + PPSoupSocketIOStatus = ^PSoupSocketIOStatus; + PSoupSocketIOStatus = ^TSoupSocketIOStatus; + TSoupSocket = object(TGObject) + //function new(optname1: Pgchar; args: array of const): PSoupSocket; cdecl; inline; static; + procedure connect_async(cancellable: PGCancellable; callback: TSoupSocketCallback; user_data: gpointer); cdecl; inline; + function connect_sync(cancellable: PGCancellable): guint; cdecl; inline; + procedure disconnect; cdecl; inline; + function get_fd: gint; cdecl; inline; + function get_local_address: PSoupAddress; cdecl; inline; + function get_remote_address: PSoupAddress; cdecl; inline; + function is_connected: gboolean; cdecl; inline; + function is_ssl: gboolean; cdecl; inline; + function listen: gboolean; cdecl; inline; + function read(buffer: gpointer; len: gsize; nread: Pgsize; cancellable: PGCancellable; error: PPGError): TSoupSocketIOStatus; cdecl; inline; + function read_until(buffer: gpointer; len: gsize; boundary: Pgpointer; boundary_len: gsize; nread: Pgsize; got_boundary: Pgboolean; cancellable: PGCancellable; error: PPGError): TSoupSocketIOStatus; cdecl; inline; + function start_proxy_ssl(ssl_host: Pgchar; cancellable: PGCancellable): gboolean; cdecl; inline; + function start_ssl(cancellable: PGCancellable): gboolean; cdecl; inline; + function write(buffer: Pgpointer; len: gsize; nwrote: Pgsize; cancellable: PGCancellable; error: PPGError): TSoupSocketIOStatus; cdecl; inline; + //property async_context: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_async_context { property is writeable but setter not declared } ; + //property clean_dispose: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_clean_dispose { property is writeable but setter not declared } ; + //property is_server: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_is_server ; + property local_address: PSoupAddress read get_local_address { property is writeable but setter not declared } ; + //property non_blocking: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_non_blocking { property is writeable but setter not declared } ; + //property proxy_resolver: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_proxy_resolver { property is writeable but setter not declared } ; + property remote_address: PSoupAddress read get_remote_address { property is writeable but setter not declared } ; + //property ssl_creds: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_ssl_creds { property is writeable but setter not declared } ; + //property ssl_fallback: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_ssl_fallback { property is writeable but setter not declared } ; + //property ssl_strict: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_ssl_strict { property is writeable but setter not declared } ; + //property timeout: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_timeout { property is writeable but setter not declared } ; + //property tls_certificate: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_tls_certificate ; + //property tls_errors: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_tls_errors ; + //property trusted_certificate: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_trusted_certificate ; + //property use_thread_context: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_use_thread_context { property is writeable but setter not declared } ; + end; + + PPSoupConnection = ^PSoupConnection; + PSoupConnection = ^TSoupConnection; + + TSoupConnection = record + end; + + + + PPSoupConnectionState = ^PSoupConnectionState; + PSoupConnectionState = ^TSoupConnectionState; + + PPSoupContentDecoderPrivate = ^PSoupContentDecoderPrivate; + PSoupContentDecoderPrivate = ^TSoupContentDecoderPrivate; + + TSoupContentDecoderPrivate = record + end; + + + + PPSoupContentDecoder = ^PSoupContentDecoder; + PSoupContentDecoder = ^TSoupContentDecoder; + TSoupContentDecoder = object(TGObject) + priv: PSoupContentDecoderPrivate; + end; + + PPSoupContentDecoderClass = ^PSoupContentDecoderClass; + PSoupContentDecoderClass = ^TSoupContentDecoderClass; + TSoupContentDecoderClass = object + parent_class: TGObjectClass; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + _libsoup_reserved5: procedure; cdecl; + end; + + PPSoupContentSniffer = ^PSoupContentSniffer; + PSoupContentSniffer = ^TSoupContentSniffer; + + PPSoupContentSnifferPrivate = ^PSoupContentSnifferPrivate; + PSoupContentSnifferPrivate = ^TSoupContentSnifferPrivate; + TSoupContentSniffer = object(TGObject) + priv: PSoupContentSnifferPrivate; + function new: PSoupContentSniffer; cdecl; inline; static; + function get_buffer_size: gsize; cdecl; inline; + function sniff(msg: PSoupMessage; buffer: PSoupBuffer; params: PPGHashTable): Pgchar; cdecl; inline; + end; + + TSoupContentSnifferPrivate = record + end; + + + + PPSoupContentSnifferClass = ^PSoupContentSnifferClass; + PSoupContentSnifferClass = ^TSoupContentSnifferClass; + TSoupContentSnifferClass = object + parent_class: TGObjectClass; + sniff: function(sniffer: PSoupContentSniffer; msg: PSoupMessage; buffer: PSoupBuffer; params: PPGHashTable): Pgchar; cdecl; + get_buffer_size: function(sniffer: PSoupContentSniffer): gsize; cdecl; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + _libsoup_reserved5: procedure; cdecl; + end; + + PPSoupDate = ^PSoupDate; + PSoupDate = ^TSoupDate; + + PPSoupDateFormat = ^PSoupDateFormat; + PSoupDateFormat = ^TSoupDateFormat; + TSoupDate = object + year: gint; + month: gint; + day: gint; + hour: gint; + minute: gint; + second: gint; + utc: gboolean; + offset: gint; + function new(year: gint; month: gint; day: gint; hour: gint; minute: gint; second: gint): PSoupDate; cdecl; inline; static; + function new_from_now(offset_seconds: gint): PSoupDate; cdecl; inline; static; + function new_from_string(date_string: Pgchar): PSoupDate; cdecl; inline; static; + function new_from_time_t(when: glong): PSoupDate; cdecl; inline; static; + function copy: PSoupDate; cdecl; inline; + procedure free; cdecl; inline; + function get_day: gint; cdecl; inline; + function get_hour: gint; cdecl; inline; + function get_minute: gint; cdecl; inline; + function get_month: gint; cdecl; inline; + function get_offset: gint; cdecl; inline; + function get_second: gint; cdecl; inline; + function get_utc: gint; cdecl; inline; + function get_year: gint; cdecl; inline; + function is_past: gboolean; cdecl; inline; + function to_string(format: TSoupDateFormat): Pgchar; cdecl; inline; + function to_time_t: glong; cdecl; inline; + procedure to_timeval(time: PGTimeVal); cdecl; inline; + end; + + PPSoupCookie = ^PSoupCookie; + PSoupCookie = ^TSoupCookie; + TSoupCookie = object + name: Pgchar; + value: Pgchar; + domain: Pgchar; + path: Pgchar; + expires: PSoupDate; + secure: gboolean; + http_only: gboolean; + function new(name: Pgchar; value: Pgchar; domain: Pgchar; path: Pgchar; max_age: gint): PSoupCookie; cdecl; inline; static; + function applies_to_uri(uri: PSoupURI): gboolean; cdecl; inline; + function copy: PSoupCookie; cdecl; inline; + function domain_matches(host: Pgchar): gboolean; cdecl; inline; + function equal(cookie2: PSoupCookie): gboolean; cdecl; inline; + procedure free; cdecl; inline; + function get_domain: Pgchar; cdecl; inline; + function get_expires: PSoupDate; cdecl; inline; + function get_http_only: gboolean; cdecl; inline; + function get_name: Pgchar; cdecl; inline; + function get_path: Pgchar; cdecl; inline; + function get_secure: gboolean; cdecl; inline; + function get_value: Pgchar; cdecl; inline; + procedure set_domain(domain: Pgchar); cdecl; inline; + procedure set_expires(expires: PSoupDate); cdecl; inline; + procedure set_http_only(http_only: gboolean); cdecl; inline; + procedure set_max_age(max_age: gint); cdecl; inline; + procedure set_name(name: Pgchar); cdecl; inline; + procedure set_path(path: Pgchar); cdecl; inline; + procedure set_secure(secure: gboolean); cdecl; inline; + procedure set_value(value: Pgchar); cdecl; inline; + function to_cookie_header: Pgchar; cdecl; inline; + function to_set_cookie_header: Pgchar; cdecl; inline; + function parse(header: Pgchar; origin: PSoupURI): PSoupCookie; cdecl; inline; static; + end; + + PPSoupCookieJar = ^PSoupCookieJar; + PSoupCookieJar = ^TSoupCookieJar; + + PPSoupCookieJarAcceptPolicy = ^PSoupCookieJarAcceptPolicy; + PSoupCookieJarAcceptPolicy = ^TSoupCookieJarAcceptPolicy; + TSoupCookieJar = object(TGObject) + function new: PSoupCookieJar; cdecl; inline; static; + procedure add_cookie(cookie: PSoupCookie); cdecl; inline; + procedure add_cookie_with_first_party(first_party: PSoupURI; cookie: PSoupCookie); cdecl; inline; + function all_cookies: PGSList; cdecl; inline; + procedure delete_cookie(cookie: PSoupCookie); cdecl; inline; + function get_accept_policy: TSoupCookieJarAcceptPolicy; cdecl; inline; + function get_cookie_list(uri: PSoupURI; for_http: gboolean): PGSList; cdecl; inline; + function get_cookies(uri: PSoupURI; for_http: gboolean): Pgchar; cdecl; inline; + function is_persistent: gboolean; cdecl; inline; + procedure set_accept_policy(policy: TSoupCookieJarAcceptPolicy); cdecl; inline; + procedure set_cookie(uri: PSoupURI; cookie: Pgchar); cdecl; inline; + procedure set_cookie_with_first_party(uri: PSoupURI; first_party: PSoupURI; cookie: Pgchar); cdecl; inline; + property accept_policy: TSoupCookieJarAcceptPolicy read get_accept_policy write set_accept_policy; + //property read_only: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_read_only { property is writeable but setter not declared } ; + end; + + PPSoupCookieJarClass = ^PSoupCookieJarClass; + PSoupCookieJarClass = ^TSoupCookieJarClass; + TSoupCookieJarClass = object + parent_class: TGObjectClass; + save: procedure(jar: PSoupCookieJar); cdecl; + is_persistent: function(jar: PSoupCookieJar): gboolean; cdecl; + changed: procedure(jar: PSoupCookieJar; old_cookie: PSoupCookie; new_cookie: PSoupCookie); cdecl; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + end; + + PPSoupCookieJarDB = ^PSoupCookieJarDB; + PSoupCookieJarDB = ^TSoupCookieJarDB; + TSoupCookieJarDB = object(TSoupCookieJar) + function new(filename: Pgchar; read_only: gboolean): PSoupCookieJarDB; cdecl; inline; static; + //property filename: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_filename { property is writeable but setter not declared } ; + end; + + PPSoupCookieJarDBClass = ^PSoupCookieJarDBClass; + PSoupCookieJarDBClass = ^TSoupCookieJarDBClass; + TSoupCookieJarDBClass = object + parent_class: TSoupCookieJarClass; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupCookieJarText = ^PSoupCookieJarText; + PSoupCookieJarText = ^TSoupCookieJarText; + TSoupCookieJarText = object(TSoupCookieJar) + function new(filename: Pgchar; read_only: gboolean): PSoupCookieJarText; cdecl; inline; static; + //property filename: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_filename { property is writeable but setter not declared } ; + end; + + PPSoupCookieJarTextClass = ^PSoupCookieJarTextClass; + PSoupCookieJarTextClass = ^TSoupCookieJarTextClass; + TSoupCookieJarTextClass = object + parent_class: TSoupCookieJarClass; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupEncoding = ^PSoupEncoding; + PSoupEncoding = ^TSoupEncoding; + + PPSoupExpectation = ^PSoupExpectation; + PSoupExpectation = ^TSoupExpectation; + + PPSoupKnownStatusCode = ^PSoupKnownStatusCode; + PSoupKnownStatusCode = ^TSoupKnownStatusCode; + + PPSoupLogger = ^PSoupLogger; + PSoupLogger = ^TSoupLogger; + + PPSoupLoggerLogLevel = ^PSoupLoggerLogLevel; + PSoupLoggerLogLevel = ^TSoupLoggerLogLevel; + + PPSoupLoggerPrinter = ^PSoupLoggerPrinter; + PSoupLoggerPrinter = ^TSoupLoggerPrinter; + TSoupLoggerPrinter = procedure(logger: PSoupLogger; level: TSoupLoggerLogLevel; direction: gchar; data: Pgchar; user_data: gpointer); cdecl; + + PPSoupLoggerFilter = ^PSoupLoggerFilter; + PSoupLoggerFilter = ^TSoupLoggerFilter; + TSoupLoggerFilter = function(logger: PSoupLogger; msg: PSoupMessage; user_data: gpointer): TSoupLoggerLogLevel; cdecl; + TSoupLogger = object(TGObject) + function new(level: TSoupLoggerLogLevel; max_body_size: gint): PSoupLogger; cdecl; inline; static; + procedure set_printer(printer: TSoupLoggerPrinter; printer_data: gpointer; destroy_: TGDestroyNotify); cdecl; inline; + procedure set_request_filter(request_filter: TSoupLoggerFilter; filter_data: gpointer; destroy_: TGDestroyNotify); cdecl; inline; + procedure set_response_filter(response_filter: TSoupLoggerFilter; filter_data: gpointer; destroy_: TGDestroyNotify); cdecl; inline; + end; + + PPSoupSessionCallback = ^PSoupSessionCallback; + PSoupSessionCallback = ^TSoupSessionCallback; + TSoupSessionCallback = procedure(session: PSoupSession; msg: PSoupMessage; user_data: gpointer); cdecl; + + PPSoupRequestHTTP = ^PSoupRequestHTTP; + PSoupRequestHTTP = ^TSoupRequestHTTP; + TSoupSession = object(TGObject) + function new: PSoupSession; cdecl; inline; static; + //function new_with_options(optname1: Pgchar; args: array of const): PSoupSession; cdecl; inline; static; + procedure abort; cdecl; inline; + procedure add_feature(feature: PSoupSessionFeature); cdecl; inline; + procedure add_feature_by_type(feature_type: TGType); cdecl; inline; + procedure cancel_message(msg: PSoupMessage; status_code: guint); cdecl; inline; + function get_async_context: PGMainContext; cdecl; inline; + function get_feature(feature_type: TGType): PSoupSessionFeature; cdecl; inline; + function get_feature_for_message(feature_type: TGType; msg: PSoupMessage): PSoupSessionFeature; cdecl; inline; + function get_features(feature_type: TGType): PGSList; cdecl; inline; + function has_feature(feature_type: TGType): gboolean; cdecl; inline; + procedure pause_message(msg: PSoupMessage); cdecl; inline; + procedure prefetch_dns(hostname: Pgchar; cancellable: PGCancellable; callback: TSoupAddressCallback; user_data: gpointer); cdecl; inline; + procedure queue_message(msg: PSoupMessage; callback: TSoupSessionCallback; user_data: gpointer); cdecl; inline; + function redirect_message(msg: PSoupMessage): gboolean; cdecl; inline; + procedure remove_feature(feature: PSoupSessionFeature); cdecl; inline; + procedure remove_feature_by_type(feature_type: TGType); cdecl; inline; + function request(uri_string: Pgchar; error: PPGError): PSoupRequest; cdecl; inline; + function request_http(method: Pgchar; uri_string: Pgchar; error: PPGError): PSoupRequestHTTP; cdecl; inline; + function request_http_uri(method: Pgchar; uri: PSoupURI; error: PPGError): PSoupRequestHTTP; cdecl; inline; + function request_uri(uri: PSoupURI; error: PPGError): PSoupRequest; cdecl; inline; + procedure requeue_message(msg: PSoupMessage); cdecl; inline; + function send(msg: PSoupMessage; cancellable: PGCancellable; error: PPGError): PGInputStream; cdecl; inline; + procedure send_async(msg: PSoupMessage; cancellable: PGCancellable; callback: TGAsyncReadyCallback; user_data: gpointer); cdecl; inline; + function send_finish(result_: PGAsyncResult; error: PPGError): PGInputStream; cdecl; inline; + function send_message(msg: PSoupMessage): guint; cdecl; inline; + procedure unpause_message(msg: PSoupMessage); cdecl; inline; + function would_redirect(msg: PSoupMessage): gboolean; cdecl; inline; + //property accept_language: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_accept_language { property is writeable but setter not declared } ; + //property accept_language_auto: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_accept_language_auto { property is writeable but setter not declared } ; + //property add_feature1: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_add_feature { property is writeable but setter not declared } ; + //property add_feature_by_type1: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_add_feature_by_type { property is writeable but setter not declared } ; + property async_context: PGMainContext read get_async_context { property is writeable but setter not declared } ; + //property http_aliases: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_http_aliases { property is writeable but setter not declared } ; + //property https_aliases: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_https_aliases { property is writeable but setter not declared } ; + //property idle_timeout: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_idle_timeout { property is writeable but setter not declared } ; + //property local_address: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_local_address { property is writeable but setter not declared } ; + //property max_conns: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_max_conns { property is writeable but setter not declared } ; + //property max_conns_per_host: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_max_conns_per_host { property is writeable but setter not declared } ; + //property proxy_resolver: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_proxy_resolver { property is writeable but setter not declared } ; + //property proxy_uri: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_proxy_uri { property is writeable but setter not declared } ; + //property remove_feature_by_type1: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_remove_feature_by_type { property is writeable but setter not declared } ; + //property ssl_ca_file: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_ssl_ca_file { property is writeable but setter not declared } ; + //property ssl_strict: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_ssl_strict { property is writeable but setter not declared } ; + //property ssl_use_system_ca_file: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_ssl_use_system_ca_file { property is writeable but setter not declared } ; + //property timeout: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_timeout { property is writeable but setter not declared } ; + //property tls_database: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_tls_database { property is writeable but setter not declared } ; + //property use_ntlm: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_use_ntlm { property is writeable but setter not declared } ; + //property use_thread_context: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_use_thread_context { property is writeable but setter not declared } ; + //property user_agent: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_user_agent { property is writeable but setter not declared } ; + end; + + PPSoupLoggerClass = ^PSoupLoggerClass; + PSoupLoggerClass = ^TSoupLoggerClass; + TSoupLoggerClass = object + parent_class: TGObjectClass; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupRequestPrivate = ^PSoupRequestPrivate; + PSoupRequestPrivate = ^TSoupRequestPrivate; + TSoupRequest = object(TGObject) + priv: PSoupRequestPrivate; + function get_content_length: gint64; cdecl; inline; + function get_content_type: Pgchar; cdecl; inline; + function get_session: PSoupSession; cdecl; inline; + function get_uri: PSoupURI; cdecl; inline; + function send(cancellable: PGCancellable; error: PPGError): PGInputStream; cdecl; inline; + procedure send_async(cancellable: PGCancellable; callback: TGAsyncReadyCallback; user_data: gpointer); cdecl; inline; + function send_finish(result_: PGAsyncResult; error: PPGError): PGInputStream; cdecl; inline; + property session: PSoupSession read get_session { property is writeable but setter not declared } ; + property uri: PSoupURI read get_uri { property is writeable but setter not declared } ; + end; + TSoupMessageBody = object + data: Pgchar; + length: gint64; + function new: PSoupMessageBody; cdecl; inline; static; + procedure append(use: TSoupMemoryUse; data: guint8; length: gsize); cdecl; inline; + procedure append_buffer(buffer: PSoupBuffer); cdecl; inline; + procedure append_take(data: Pguint8; length: gsize); cdecl; inline; + procedure complete; cdecl; inline; + function flatten: PSoupBuffer; cdecl; inline; + procedure free; cdecl; inline; + function get_accumulate: gboolean; cdecl; inline; + function get_chunk(offset: gint64): PSoupBuffer; cdecl; inline; + procedure got_chunk(chunk: PSoupBuffer); cdecl; inline; + procedure set_accumulate(accumulate: gboolean); cdecl; inline; + procedure truncate; cdecl; inline; + procedure wrote_chunk(chunk: PSoupBuffer); cdecl; inline; + end; + + PPSoupMessageHeadersType = ^PSoupMessageHeadersType; + PSoupMessageHeadersType = ^TSoupMessageHeadersType; + + PPSoupMessageHeadersForeachFunc = ^PSoupMessageHeadersForeachFunc; + PSoupMessageHeadersForeachFunc = ^TSoupMessageHeadersForeachFunc; + TSoupMessageHeadersForeachFunc = procedure(name: Pgchar; value: Pgchar; user_data: gpointer); cdecl; + + PPSoupRange = ^PSoupRange; + PSoupRange = ^TSoupRange; + TSoupMessageHeaders = object + function new(type_: TSoupMessageHeadersType): PSoupMessageHeaders; cdecl; inline; static; + procedure append(name: Pgchar; value: Pgchar); cdecl; inline; + procedure clean_connection_headers; cdecl; inline; + procedure clear; cdecl; inline; + procedure foreach(func: TSoupMessageHeadersForeachFunc; user_data: gpointer); cdecl; inline; + procedure free; cdecl; inline; + procedure free_ranges(ranges: PSoupRange); cdecl; inline; + function get_content_disposition(disposition: PPgchar; params: PPGHashTable): gboolean; cdecl; inline; + function get_content_length: gint64; cdecl; inline; + function get_content_range(start: Pgint64; end_: Pgint64; total_length: Pgint64): gboolean; cdecl; inline; + function get_content_type(params: PPGHashTable): Pgchar; cdecl; inline; + function get_encoding: TSoupEncoding; cdecl; inline; + function get_expectations: TSoupExpectation; cdecl; inline; + function get_list(name: Pgchar): Pgchar; cdecl; inline; + function get_one(name: Pgchar): Pgchar; cdecl; inline; + function get_ranges(total_length: gint64; ranges: PPSoupRange; length: Pgint): gboolean; cdecl; inline; + procedure remove(name: Pgchar); cdecl; inline; + procedure replace(name: Pgchar; value: Pgchar); cdecl; inline; + procedure set_content_disposition(disposition: Pgchar; params: PGHashTable); cdecl; inline; + procedure set_content_length(content_length: gint64); cdecl; inline; + procedure set_content_range(start: gint64; end_: gint64; total_length: gint64); cdecl; inline; + procedure set_content_type(content_type: Pgchar; params: PGHashTable); cdecl; inline; + procedure set_encoding(encoding: TSoupEncoding); cdecl; inline; + procedure set_expectations(expectations: TSoupExpectation); cdecl; inline; + procedure set_range(start: gint64; end_: gint64); cdecl; inline; + procedure set_ranges(ranges: PSoupRange; length: gint); cdecl; inline; + end; + + PPSoupMessageClass = ^PSoupMessageClass; + PSoupMessageClass = ^TSoupMessageClass; + TSoupMessageClass = object + parent_class: TGObjectClass; + wrote_informational: procedure(msg: PSoupMessage); cdecl; + wrote_headers: procedure(msg: PSoupMessage); cdecl; + wrote_chunk: procedure(msg: PSoupMessage); cdecl; + wrote_body: procedure(msg: PSoupMessage); cdecl; + got_informational: procedure(msg: PSoupMessage); cdecl; + got_headers: procedure(msg: PSoupMessage); cdecl; + got_chunk: procedure(msg: PSoupMessage; chunk: PSoupBuffer); cdecl; + got_body: procedure(msg: PSoupMessage); cdecl; + restarted: procedure(msg: PSoupMessage); cdecl; + finished: procedure(msg: PSoupMessage); cdecl; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + TSoupRange = record + start: gint64; + end_: gint64; + end; + + + + PPSoupMessageHeadersIter = ^PSoupMessageHeadersIter; + PSoupMessageHeadersIter = ^TSoupMessageHeadersIter; + TSoupMessageHeadersIter = object + dummy: array [0..2] of gpointer; + function next(name: PPgchar; value: PPgchar): gboolean; cdecl; inline; + procedure init(iter: PSoupMessageHeadersIter; hdrs: PSoupMessageHeaders); cdecl; inline; static; + end; + + PPSoupMessageQueue = ^PSoupMessageQueue; + PSoupMessageQueue = ^TSoupMessageQueue; + + TSoupMessageQueue = record + end; + + + + PPSoupMessageQueueItem = ^PSoupMessageQueueItem; + PSoupMessageQueueItem = ^TSoupMessageQueueItem; + + TSoupMessageQueueItem = record + end; + + + + PPSoupMultipart = ^PSoupMultipart; + PSoupMultipart = ^TSoupMultipart; + TSoupMultipart = object + function new(mime_type: Pgchar): PSoupMultipart; cdecl; inline; static; + function new_from_message(headers: PSoupMessageHeaders; body: PSoupMessageBody): PSoupMultipart; cdecl; inline; static; + procedure append_form_file(control_name: Pgchar; filename: Pgchar; content_type: Pgchar; body: PSoupBuffer); cdecl; inline; + procedure append_form_string(control_name: Pgchar; data: Pgchar); cdecl; inline; + procedure append_part(headers: PSoupMessageHeaders; body: PSoupBuffer); cdecl; inline; + procedure free; cdecl; inline; + function get_length: gint; cdecl; inline; + function get_part(part: gint; headers: PPSoupMessageHeaders; body: PPSoupBuffer): gboolean; cdecl; inline; + procedure to_message(dest_headers: PSoupMessageHeaders; dest_body: PSoupMessageBody); cdecl; inline; + end; + + PPSoupMultipartInputStream = ^PSoupMultipartInputStream; + PSoupMultipartInputStream = ^TSoupMultipartInputStream; + + PPSoupMultipartInputStreamPrivate = ^PSoupMultipartInputStreamPrivate; + PSoupMultipartInputStreamPrivate = ^TSoupMultipartInputStreamPrivate; + TSoupMultipartInputStream = object(TGFilterInputStream) + priv1: PSoupMultipartInputStreamPrivate; + function new(msg: PSoupMessage; base_stream: PGInputStream): PSoupMultipartInputStream; cdecl; inline; static; + function get_headers: PSoupMessageHeaders; cdecl; inline; + function next_part(cancellable: PGCancellable; error: PPGError): PGInputStream; cdecl; inline; + procedure next_part_async(io_priority: gint; cancellable: PGCancellable; callback: TGAsyncReadyCallback; data: gpointer); cdecl; inline; + function next_part_finish(result_: PGAsyncResult; error: PPGError): PGInputStream; cdecl; inline; + //property message: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_message { property is writeable but setter not declared } ; + end; + + TSoupMultipartInputStreamPrivate = record + end; + + + + PPSoupMultipartInputStreamClass = ^PSoupMultipartInputStreamClass; + PSoupMultipartInputStreamClass = ^TSoupMultipartInputStreamClass; + TSoupMultipartInputStreamClass = object + parent_class: TGFilterInputStreamClass; + end; + + PPSoupPasswordManager = ^PSoupPasswordManager; + PSoupPasswordManager = ^TSoupPasswordManager; + + PPSoupPasswordManagerCallback = ^PSoupPasswordManagerCallback; + PSoupPasswordManagerCallback = ^TSoupPasswordManagerCallback; + TSoupPasswordManagerCallback = procedure(arg0: PSoupPasswordManager; arg1: PSoupMessage; arg2: PSoupAuth; retrying: gboolean; user_data: gpointer); cdecl; + TSoupPasswordManager = object + procedure get_passwords_async(msg: PSoupMessage; auth: PSoupAuth; retrying: gboolean; async_context: PGMainContext; cancellable: PGCancellable; callback: TSoupPasswordManagerCallback; user_data: gpointer); cdecl; inline; + procedure get_passwords_sync(msg: PSoupMessage; auth: PSoupAuth; cancellable: PGCancellable); cdecl; inline; + end; + + PPSoupPasswordManagerInterface = ^PSoupPasswordManagerInterface; + PSoupPasswordManagerInterface = ^TSoupPasswordManagerInterface; + TSoupPasswordManagerInterface = object + base: TGTypeInterface; + get_passwords_async: procedure(arg0: PSoupPasswordManager; arg1: PSoupMessage; arg2: PSoupAuth; arg3: gboolean; arg4: PGMainContext; arg5: PGCancellable; arg6: TSoupPasswordManagerCallback; arg7: gpointer); cdecl; + get_passwords_sync: procedure(arg0: PSoupPasswordManager; arg1: PSoupMessage; arg2: PSoupAuth; arg3: PGCancellable); cdecl; + end; + + PPSoupProxyURIResolver = ^PSoupProxyURIResolver; + PSoupProxyURIResolver = ^TSoupProxyURIResolver; + + PPSoupProxyURIResolverCallback = ^PSoupProxyURIResolverCallback; + PSoupProxyURIResolverCallback = ^TSoupProxyURIResolverCallback; + TSoupProxyURIResolverCallback = procedure(resolver: PSoupProxyURIResolver; status: guint; proxy_uri: PSoupURI; user_data: gpointer); cdecl; + TSoupProxyURIResolver = object + procedure get_proxy_uri_async(uri: PSoupURI; async_context: PGMainContext; cancellable: PGCancellable; callback: TSoupProxyURIResolverCallback; user_data: gpointer); cdecl; inline; + function get_proxy_uri_sync(uri: PSoupURI; cancellable: PGCancellable; proxy_uri: PPSoupURI): guint; cdecl; inline; + end; + + PPSoupProxyResolverDefault = ^PSoupProxyResolverDefault; + PSoupProxyResolverDefault = ^TSoupProxyResolverDefault; + TSoupProxyResolverDefault = object(TGObject) + //property gproxy_resolver: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_gproxy_resolver { property is writeable but setter not declared } ; + end; + + PPSoupProxyResolverDefaultClass = ^PSoupProxyResolverDefaultClass; + PSoupProxyResolverDefaultClass = ^TSoupProxyResolverDefaultClass; + TSoupProxyResolverDefaultClass = object + parent_class: TGObjectClass; + end; + + PPSoupProxyURIResolverInterface = ^PSoupProxyURIResolverInterface; + PSoupProxyURIResolverInterface = ^TSoupProxyURIResolverInterface; + TSoupProxyURIResolverInterface = object + base: TGTypeInterface; + get_proxy_uri_async: procedure(proxy_uri_resolver: PSoupProxyURIResolver; uri: PSoupURI; async_context: PGMainContext; cancellable: PGCancellable; callback: TSoupProxyURIResolverCallback; user_data: gpointer); cdecl; + get_proxy_uri_sync: function(proxy_uri_resolver: PSoupProxyURIResolver; uri: PSoupURI; cancellable: PGCancellable; proxy_uri: PPSoupURI): guint; cdecl; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + TSoupRequestPrivate = record + end; + + + + PPSoupRequestClass = ^PSoupRequestClass; + PSoupRequestClass = ^TSoupRequestClass; + TSoupRequestClass = object + parent: TGObjectClass; + schemes: PPgchar; + check_uri: function(req_base: PSoupRequest; uri: PSoupURI; error: PPGError): gboolean; cdecl; + send: function(request: PSoupRequest; cancellable: PGCancellable; error: PPGError): PGInputStream; cdecl; + send_async: procedure(request: PSoupRequest; cancellable: PGCancellable; callback: TGAsyncReadyCallback; user_data: gpointer); cdecl; + send_finish: function(request: PSoupRequest; result_: PGAsyncResult; error: PPGError): PGInputStream; cdecl; + get_content_length: function(request: PSoupRequest): gint64; cdecl; + get_content_type: function(request: PSoupRequest): Pgchar; cdecl; + end; + + PPSoupRequestDataPrivate = ^PSoupRequestDataPrivate; + PSoupRequestDataPrivate = ^TSoupRequestDataPrivate; + + TSoupRequestDataPrivate = record + end; + + + + PPSoupRequestData = ^PSoupRequestData; + PSoupRequestData = ^TSoupRequestData; + TSoupRequestData = object(TSoupRequest) + priv1: PSoupRequestDataPrivate; + end; + + PPSoupRequestDataClass = ^PSoupRequestDataClass; + PSoupRequestDataClass = ^TSoupRequestDataClass; + TSoupRequestDataClass = object + parent: TSoupRequestClass; + end; + + PPSoupRequestError = ^PSoupRequestError; + PSoupRequestError = ^TSoupRequestError; + + PPSoupRequestFile = ^PSoupRequestFile; + PSoupRequestFile = ^TSoupRequestFile; + + PPSoupRequestFilePrivate = ^PSoupRequestFilePrivate; + PSoupRequestFilePrivate = ^TSoupRequestFilePrivate; + TSoupRequestFile = object(TSoupRequest) + priv1: PSoupRequestFilePrivate; + function get_file: PGFile; cdecl; inline; + end; + + TSoupRequestFilePrivate = record + end; + + + + PPSoupRequestFileClass = ^PSoupRequestFileClass; + PSoupRequestFileClass = ^TSoupRequestFileClass; + TSoupRequestFileClass = object + parent: TSoupRequestClass; + end; + + PPSoupRequestHTTPPrivate = ^PSoupRequestHTTPPrivate; + PSoupRequestHTTPPrivate = ^TSoupRequestHTTPPrivate; + TSoupRequestHTTP = object(TSoupRequest) + priv1: PSoupRequestHTTPPrivate; + function get_message: PSoupMessage; cdecl; inline; + end; + + TSoupRequestHTTPPrivate = record + end; + + + + PPSoupRequestHTTPClass = ^PSoupRequestHTTPClass; + PSoupRequestHTTPClass = ^TSoupRequestHTTPClass; + TSoupRequestHTTPClass = object + parent: TSoupRequestClass; + end; + + PPSoupRequester = ^PSoupRequester; + PSoupRequester = ^TSoupRequester; + + PPSoupRequesterPrivate = ^PSoupRequesterPrivate; + PSoupRequesterPrivate = ^TSoupRequesterPrivate; + TSoupRequester = object(TGObject) + priv: PSoupRequesterPrivate; + function new: PSoupRequester; cdecl; inline; static; + function request(uri_string: Pgchar; error: PPGError): PSoupRequest; cdecl; inline; + function request_uri(uri: PSoupURI; error: PPGError): PSoupRequest; cdecl; inline; + end; + + TSoupRequesterPrivate = record + end; + + + + PPSoupRequesterClass = ^PSoupRequesterClass; + PSoupRequesterClass = ^TSoupRequesterClass; + TSoupRequesterClass = object + parent_class: TGObjectClass; + end; + + PPSoupRequesterError = ^PSoupRequesterError; + PSoupRequesterError = ^TSoupRequesterError; + + PPSoupServer = ^PSoupServer; + PSoupServer = ^TSoupServer; + + PPSoupServerCallback = ^PSoupServerCallback; + PSoupServerCallback = ^TSoupServerCallback; + TSoupServerCallback = procedure(server: PSoupServer; msg: PSoupMessage; path: Pgchar; query: PGHashTable; client: PSoupClientContext; user_data: gpointer); cdecl; + TSoupServer = object(TGObject) + //function new(optname1: Pgchar; args: array of const): PSoupServer; cdecl; inline; static; + procedure add_auth_domain(auth_domain: PSoupAuthDomain); cdecl; inline; + procedure add_handler(path: Pgchar; callback: TSoupServerCallback; user_data: gpointer; destroy_: TGDestroyNotify); cdecl; inline; + procedure disconnect; cdecl; inline; + function get_async_context: PGMainContext; cdecl; inline; + function get_listener: PSoupSocket; cdecl; inline; + function get_port: guint; cdecl; inline; + function is_https: gboolean; cdecl; inline; + procedure pause_message(msg: PSoupMessage); cdecl; inline; + procedure quit; cdecl; inline; + procedure remove_auth_domain(auth_domain: PSoupAuthDomain); cdecl; inline; + procedure remove_handler(path: Pgchar); cdecl; inline; + procedure run; cdecl; inline; + procedure run_async; cdecl; inline; + procedure unpause_message(msg: PSoupMessage); cdecl; inline; + property async_context: PGMainContext read get_async_context { property is writeable but setter not declared } ; + //property interface_: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_interface { property is writeable but setter not declared } ; + property port: guint read get_port { property is writeable but setter not declared } ; + //property raw_paths: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_raw_paths { property is writeable but setter not declared } ; + //property server_header: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_server_header { property is writeable but setter not declared } ; + //property ssl_cert_file: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_ssl_cert_file { property is writeable but setter not declared } ; + //property ssl_key_file: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_ssl_key_file { property is writeable but setter not declared } ; + //property tls_certificate: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_tls_certificate { property is writeable but setter not declared } ; + end; + + PPSoupServerClass = ^PSoupServerClass; + PSoupServerClass = ^TSoupServerClass; + TSoupServerClass = object + parent_class: TGObjectClass; + request_started: procedure(server: PSoupServer; msg: PSoupMessage; client: PSoupClientContext); cdecl; + request_read: procedure(server: PSoupServer; msg: PSoupMessage; client: PSoupClientContext); cdecl; + request_finished: procedure(server: PSoupServer; msg: PSoupMessage; client: PSoupClientContext); cdecl; + request_aborted: procedure(server: PSoupServer; msg: PSoupMessage; client: PSoupClientContext); cdecl; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupSessionAsync = ^PSoupSessionAsync; + PSoupSessionAsync = ^TSoupSessionAsync; + TSoupSessionAsync = object(TSoupSession) + end; + + PPSoupSessionClass = ^PSoupSessionClass; + PSoupSessionClass = ^TSoupSessionClass; + TSoupSessionClass = object + parent_class: TGObjectClass; + request_started: procedure(session: PSoupSession; msg: PSoupMessage; socket: PSoupSocket); cdecl; + authenticate: procedure(session: PSoupSession; msg: PSoupMessage; auth: PSoupAuth; retrying: gboolean); cdecl; + queue_message: procedure(session: PSoupSession; msg: PSoupMessage; callback: TSoupSessionCallback; user_data: gpointer); cdecl; + requeue_message: procedure(session: PSoupSession; msg: PSoupMessage); cdecl; + send_message: function(session: PSoupSession; msg: PSoupMessage): guint; cdecl; + cancel_message: procedure(session: PSoupSession; msg: PSoupMessage; status_code: guint); cdecl; + auth_required: procedure(session: PSoupSession; msg: PSoupMessage; auth: PSoupAuth; retrying: gboolean); cdecl; + flush_queue: procedure(session: PSoupSession); cdecl; + kick: procedure(session: PSoupSession); cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupSessionAsyncClass = ^PSoupSessionAsyncClass; + PSoupSessionAsyncClass = ^TSoupSessionAsyncClass; + TSoupSessionAsyncClass = object + parent_class: TSoupSessionClass; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupSessionFeatureInterface = ^PSoupSessionFeatureInterface; + PSoupSessionFeatureInterface = ^TSoupSessionFeatureInterface; + TSoupSessionFeatureInterface = object + parent: TGTypeInterface; + attach: procedure(feature: PSoupSessionFeature; session: PSoupSession); cdecl; + detach: procedure(feature: PSoupSessionFeature; session: PSoupSession); cdecl; + request_queued: procedure(feature: PSoupSessionFeature; session: PSoupSession; msg: PSoupMessage); cdecl; + request_started: procedure(feature: PSoupSessionFeature; session: PSoupSession; msg: PSoupMessage; socket: PSoupSocket); cdecl; + request_unqueued: procedure(feature: PSoupSessionFeature; session: PSoupSession; msg: PSoupMessage); cdecl; + add_feature: function(feature: PSoupSessionFeature; type_: TGType): gboolean; cdecl; + remove_feature: function(feature: PSoupSessionFeature; type_: TGType): gboolean; cdecl; + has_feature: function(feature: PSoupSessionFeature; type_: TGType): gboolean; cdecl; + end; + + PPSoupSessionSync = ^PSoupSessionSync; + PSoupSessionSync = ^TSoupSessionSync; + TSoupSessionSync = object(TSoupSession) + end; + + PPSoupSessionSyncClass = ^PSoupSessionSyncClass; + PSoupSessionSyncClass = ^TSoupSessionSyncClass; + TSoupSessionSyncClass = object + parent_class: TSoupSessionClass; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupSocketClass = ^PSoupSocketClass; + PSoupSocketClass = ^TSoupSocketClass; + TSoupSocketClass = object + parent_class: TGObjectClass; + readable: procedure(arg0: PSoupSocket); cdecl; + writable: procedure(arg0: PSoupSocket); cdecl; + disconnected: procedure(arg0: PSoupSocket); cdecl; + new_connection: procedure(arg0: PSoupSocket; arg1: PSoupSocket); cdecl; + _libsoup_reserved1: procedure; cdecl; + _libsoup_reserved2: procedure; cdecl; + _libsoup_reserved3: procedure; cdecl; + _libsoup_reserved4: procedure; cdecl; + end; + + PPSoupTLDError = ^PSoupTLDError; + PSoupTLDError = ^TSoupTLDError; + + PPSoupXMLRPCError = ^PSoupXMLRPCError; + PSoupXMLRPCError = ^TSoupXMLRPCError; + + PPSoupXMLRPCFault = ^PSoupXMLRPCFault; + PSoupXMLRPCFault = ^TSoupXMLRPCFault; + +function soup_add_completion(async_context: PGMainContext; function_: TGSourceFunc; data: gpointer): PGSource; cdecl; external; +function soup_add_idle(async_context: PGMainContext; function_: TGSourceFunc; data: gpointer): PGSource; cdecl; external; +function soup_add_io_watch(async_context: PGMainContext; chan: PGIOChannel; condition: TGIOCondition; function_: TGIOFunc; data: gpointer): PGSource; cdecl; external; +function soup_add_timeout(async_context: PGMainContext; interval: guint; function_: TGSourceFunc; data: gpointer): PGSource; cdecl; external; +function soup_address_equal_by_ip(addr1: PSoupAddress; addr2: PSoupAddress): gboolean; cdecl; external; +function soup_address_equal_by_name(addr1: PSoupAddress; addr2: PSoupAddress): gboolean; cdecl; external; +function soup_address_get_gsockaddr(addr: PSoupAddress): PGSocketAddress; cdecl; external; +function soup_address_get_name(addr: PSoupAddress): Pgchar; cdecl; external; +function soup_address_get_physical(addr: PSoupAddress): Pgchar; cdecl; external; +function soup_address_get_port(addr: PSoupAddress): guint; cdecl; external; +function soup_address_get_sockaddr(addr: PSoupAddress; len: Pgint): Pgpointer; cdecl; external; +function soup_address_get_type: TGType; cdecl; external; +function soup_address_hash_by_ip(addr: PSoupAddress): guint; cdecl; external; +function soup_address_hash_by_name(addr: PSoupAddress): guint; cdecl; external; +function soup_address_is_resolved(addr: PSoupAddress): gboolean; cdecl; external; +function soup_address_new(name: Pgchar; port: guint): PSoupAddress; cdecl; external; +function soup_address_new_any(family: TSoupAddressFamily; port: guint): PSoupAddress; cdecl; external; +function soup_address_new_from_sockaddr(sa: Pgpointer; len: gint): PSoupAddress; cdecl; external; +function soup_address_resolve_sync(addr: PSoupAddress; cancellable: PGCancellable): guint; cdecl; external; +function soup_auth_basic_get_type: TGType; cdecl; external; +function soup_auth_digest_get_type: TGType; cdecl; external; +function soup_auth_domain_accepts(domain: PSoupAuthDomain; msg: PSoupMessage): Pgchar; cdecl; external; +function soup_auth_domain_basic_get_type: TGType; cdecl; external; +function soup_auth_domain_basic_new(optname1: Pgchar; args: array of const): PSoupAuthDomainBasic; cdecl; external; +function soup_auth_domain_check_password(domain: PSoupAuthDomain; msg: PSoupMessage; username: Pgchar; password: Pgchar): gboolean; cdecl; external; +function soup_auth_domain_covers(domain: PSoupAuthDomain; msg: PSoupMessage): gboolean; cdecl; external; +function soup_auth_domain_digest_encode_password(username: Pgchar; realm: Pgchar; password: Pgchar): Pgchar; cdecl; external; +function soup_auth_domain_digest_get_type: TGType; cdecl; external; +function soup_auth_domain_digest_new(optname1: Pgchar; args: array of const): PSoupAuthDomainDigest; cdecl; external; +function soup_auth_domain_get_realm(domain: PSoupAuthDomain): Pgchar; cdecl; external; +function soup_auth_domain_get_type: TGType; cdecl; external; +function soup_auth_domain_try_generic_auth_callback(domain: PSoupAuthDomain; msg: PSoupMessage; username: Pgchar): gboolean; cdecl; external; +function soup_auth_get_authorization(auth: PSoupAuth; msg: PSoupMessage): Pgchar; cdecl; external; +function soup_auth_get_host(auth: PSoupAuth): Pgchar; cdecl; external; +function soup_auth_get_info(auth: PSoupAuth): Pgchar; cdecl; external; +function soup_auth_get_protection_space(auth: PSoupAuth; source_uri: PSoupURI): PGSList; cdecl; external; +function soup_auth_get_realm(auth: PSoupAuth): Pgchar; cdecl; external; +function soup_auth_get_saved_password(auth: PSoupAuth; user: Pgchar): Pgchar; cdecl; external; +function soup_auth_get_saved_users(auth: PSoupAuth): PGSList; cdecl; external; +function soup_auth_get_scheme_name(auth: PSoupAuth): Pgchar; cdecl; external; +function soup_auth_get_type: TGType; cdecl; external; +function soup_auth_is_authenticated(auth: PSoupAuth): gboolean; cdecl; external; +function soup_auth_is_for_proxy(auth: PSoupAuth): gboolean; cdecl; external; +function soup_auth_is_ready(auth: PSoupAuth; msg: PSoupMessage): gboolean; cdecl; external; +function soup_auth_manager_get_type: TGType; cdecl; external; +function soup_auth_new(type_: TGType; msg: PSoupMessage; auth_header: Pgchar): PSoupAuth; cdecl; external; +function soup_auth_ntlm_get_type: TGType; cdecl; external; +function soup_auth_update(auth: PSoupAuth; msg: PSoupMessage; auth_header: Pgchar): gboolean; cdecl; external; +function soup_buffer_copy(buffer: PSoupBuffer): PSoupBuffer; cdecl; external; +function soup_buffer_get_as_bytes(buffer: PSoupBuffer): PGBytes; cdecl; external; +function soup_buffer_get_owner(buffer: PSoupBuffer): gpointer; cdecl; external; +function soup_buffer_get_type: TGType; cdecl; external; +function soup_buffer_new(use: TSoupMemoryUse; data: Pgpointer; length: gsize): PSoupBuffer; cdecl; external; +function soup_buffer_new_subbuffer(parent: PSoupBuffer; offset: gsize; length: gsize): PSoupBuffer; cdecl; external; +function soup_buffer_new_take(data: Pguint8; length: gsize): PSoupBuffer; cdecl; external; +function soup_buffer_new_with_owner(data: Pgpointer; length: gsize; owner: gpointer; owner_dnotify: TGDestroyNotify): PSoupBuffer; cdecl; external; +function soup_cache_get_max_size(cache: PSoupCache): guint; cdecl; external; +function soup_cache_get_type: TGType; cdecl; external; +function soup_cache_new(cache_dir: Pgchar; cache_type: TSoupCacheType): PSoupCache; cdecl; external; +function soup_client_context_get_address(client: PSoupClientContext): PSoupAddress; cdecl; external; +function soup_client_context_get_auth_domain(client: PSoupClientContext): PSoupAuthDomain; cdecl; external; +function soup_client_context_get_auth_user(client: PSoupClientContext): Pgchar; cdecl; external; +function soup_client_context_get_host(client: PSoupClientContext): Pgchar; cdecl; external; +function soup_client_context_get_socket(client: PSoupClientContext): PSoupSocket; cdecl; external; +function soup_client_context_get_type: TGType; cdecl; external; +function soup_content_decoder_get_type: TGType; cdecl; external; +function soup_content_sniffer_get_buffer_size(sniffer: PSoupContentSniffer): gsize; cdecl; external; +function soup_content_sniffer_get_type: TGType; cdecl; external; +function soup_content_sniffer_new: PSoupContentSniffer; cdecl; external; +function soup_content_sniffer_sniff(sniffer: PSoupContentSniffer; msg: PSoupMessage; buffer: PSoupBuffer; params: PPGHashTable): Pgchar; cdecl; external; +function soup_cookie_applies_to_uri(cookie: PSoupCookie; uri: PSoupURI): gboolean; cdecl; external; +function soup_cookie_copy(cookie: PSoupCookie): PSoupCookie; cdecl; external; +function soup_cookie_domain_matches(cookie: PSoupCookie; host: Pgchar): gboolean; cdecl; external; +function soup_cookie_equal(cookie1: PSoupCookie; cookie2: PSoupCookie): gboolean; cdecl; external; +function soup_cookie_get_domain(cookie: PSoupCookie): Pgchar; cdecl; external; +function soup_cookie_get_expires(cookie: PSoupCookie): PSoupDate; cdecl; external; +function soup_cookie_get_http_only(cookie: PSoupCookie): gboolean; cdecl; external; +function soup_cookie_get_name(cookie: PSoupCookie): Pgchar; cdecl; external; +function soup_cookie_get_path(cookie: PSoupCookie): Pgchar; cdecl; external; +function soup_cookie_get_secure(cookie: PSoupCookie): gboolean; cdecl; external; +function soup_cookie_get_type: TGType; cdecl; external; +function soup_cookie_get_value(cookie: PSoupCookie): Pgchar; cdecl; external; +function soup_cookie_jar_all_cookies(jar: PSoupCookieJar): PGSList; cdecl; external; +function soup_cookie_jar_db_get_type: TGType; cdecl; external; +function soup_cookie_jar_db_new(filename: Pgchar; read_only: gboolean): PSoupCookieJarDB; cdecl; external; +function soup_cookie_jar_get_accept_policy(jar: PSoupCookieJar): TSoupCookieJarAcceptPolicy; cdecl; external; +function soup_cookie_jar_get_cookie_list(jar: PSoupCookieJar; uri: PSoupURI; for_http: gboolean): PGSList; cdecl; external; +function soup_cookie_jar_get_cookies(jar: PSoupCookieJar; uri: PSoupURI; for_http: gboolean): Pgchar; cdecl; external; +function soup_cookie_jar_get_type: TGType; cdecl; external; +function soup_cookie_jar_is_persistent(jar: PSoupCookieJar): gboolean; cdecl; external; +function soup_cookie_jar_new: PSoupCookieJar; cdecl; external; +function soup_cookie_jar_text_get_type: TGType; cdecl; external; +function soup_cookie_jar_text_new(filename: Pgchar; read_only: gboolean): PSoupCookieJarText; cdecl; external; +function soup_cookie_new(name: Pgchar; value: Pgchar; domain: Pgchar; path: Pgchar; max_age: gint): PSoupCookie; cdecl; external; +function soup_cookie_parse(header: Pgchar; origin: PSoupURI): PSoupCookie; cdecl; external; +function soup_cookie_to_cookie_header(cookie: PSoupCookie): Pgchar; cdecl; external; +function soup_cookie_to_set_cookie_header(cookie: PSoupCookie): Pgchar; cdecl; external; +function soup_cookies_from_request(msg: PSoupMessage): PGSList; cdecl; external; +function soup_cookies_from_response(msg: PSoupMessage): PGSList; cdecl; external; +function soup_cookies_to_cookie_header(cookies: PGSList): Pgchar; cdecl; external; +function soup_date_copy(date: PSoupDate): PSoupDate; cdecl; external; +function soup_date_get_day(date: PSoupDate): gint; cdecl; external; +function soup_date_get_hour(date: PSoupDate): gint; cdecl; external; +function soup_date_get_minute(date: PSoupDate): gint; cdecl; external; +function soup_date_get_month(date: PSoupDate): gint; cdecl; external; +function soup_date_get_offset(date: PSoupDate): gint; cdecl; external; +function soup_date_get_second(date: PSoupDate): gint; cdecl; external; +function soup_date_get_type: TGType; cdecl; external; +function soup_date_get_utc(date: PSoupDate): gint; cdecl; external; +function soup_date_get_year(date: PSoupDate): gint; cdecl; external; +function soup_date_is_past(date: PSoupDate): gboolean; cdecl; external; +function soup_date_new(year: gint; month: gint; day: gint; hour: gint; minute: gint; second: gint): PSoupDate; cdecl; external; +function soup_date_new_from_now(offset_seconds: gint): PSoupDate; cdecl; external; +function soup_date_new_from_string(date_string: Pgchar): PSoupDate; cdecl; external; +function soup_date_new_from_time_t(when: glong): PSoupDate; cdecl; external; +function soup_date_to_string(date: PSoupDate; format: TSoupDateFormat): Pgchar; cdecl; external; +function soup_date_to_time_t(date: PSoupDate): glong; cdecl; external; +function soup_form_decode(encoded_form: Pgchar): PGHashTable; cdecl; external; +function soup_form_decode_multipart(msg: PSoupMessage; file_control_name: Pgchar; filename: PPgchar; content_type: PPgchar; file_: PPSoupBuffer): PGHashTable; cdecl; external; +function soup_form_encode(first_field: Pgchar; args: array of const): Pgchar; cdecl; external; +function soup_form_encode_datalist(form_data_set: PPGData): Pgchar; cdecl; external; +function soup_form_encode_hash(form_data_set: PGHashTable): Pgchar; cdecl; external; +function soup_form_encode_valist(first_field: Pgchar; args: Tva_list): Pgchar; cdecl; external; +function soup_form_request_new(method: Pgchar; uri: Pgchar; first_field: Pgchar; args: array of const): PSoupMessage; cdecl; external; +function soup_form_request_new_from_datalist(method: Pgchar; uri: Pgchar; form_data_set: PPGData): PSoupMessage; cdecl; external; +function soup_form_request_new_from_hash(method: Pgchar; uri: Pgchar; form_data_set: PGHashTable): PSoupMessage; cdecl; external; +function soup_form_request_new_from_multipart(uri: Pgchar; multipart: PSoupMultipart): PSoupMessage; cdecl; external; +function soup_header_contains(header: Pgchar; token: Pgchar): gboolean; cdecl; external; +function soup_header_parse_list(header: Pgchar): PGSList; cdecl; external; +function soup_header_parse_param_list(header: Pgchar): PGHashTable; cdecl; external; +function soup_header_parse_quality_list(header: Pgchar; unacceptable: PPGSList): PGSList; cdecl; external; +function soup_header_parse_semi_param_list(header: Pgchar): PGHashTable; cdecl; external; +function soup_headers_parse(str: Pgchar; len: gint; dest: PSoupMessageHeaders): gboolean; cdecl; external; +function soup_headers_parse_request(str: Pgchar; len: gint; req_headers: PSoupMessageHeaders; req_method: PPgchar; req_path: PPgchar; ver: PSoupHTTPVersion): guint; cdecl; external; +function soup_headers_parse_response(str: Pgchar; len: gint; headers: PSoupMessageHeaders; ver: PSoupHTTPVersion; status_code: Pguint; reason_phrase: PPgchar): gboolean; cdecl; external; +function soup_headers_parse_status_line(status_line: Pgchar; ver: PSoupHTTPVersion; status_code: Pguint; reason_phrase: PPgchar): gboolean; cdecl; external; +function soup_http_error_quark: TGQuark; cdecl; external; +function soup_logger_get_type: TGType; cdecl; external; +function soup_logger_new(level: TSoupLoggerLogLevel; max_body_size: gint): PSoupLogger; cdecl; external; +function soup_message_add_header_handler(msg: PSoupMessage; signal: Pgchar; header: Pgchar; callback: TGCallback; user_data: gpointer): guint; cdecl; external; +function soup_message_add_status_code_handler(msg: PSoupMessage; signal: Pgchar; status_code: guint; callback: TGCallback; user_data: gpointer): guint; cdecl; external; +function soup_message_body_flatten(body: PSoupMessageBody): PSoupBuffer; cdecl; external; +function soup_message_body_get_accumulate(body: PSoupMessageBody): gboolean; cdecl; external; +function soup_message_body_get_chunk(body: PSoupMessageBody; offset: gint64): PSoupBuffer; cdecl; external; +function soup_message_body_get_type: TGType; cdecl; external; +function soup_message_body_new: PSoupMessageBody; cdecl; external; +function soup_message_get_address(msg: PSoupMessage): PSoupAddress; cdecl; external; +function soup_message_get_first_party(msg: PSoupMessage): PSoupURI; cdecl; external; +function soup_message_get_flags(msg: PSoupMessage): TSoupMessageFlags; cdecl; external; +function soup_message_get_http_version(msg: PSoupMessage): TSoupHTTPVersion; cdecl; external; +function soup_message_get_https_status(msg: PSoupMessage; certificate: PPGTlsCertificate; errors: PGTlsCertificateFlags): gboolean; cdecl; external; +function soup_message_get_soup_request(msg: PSoupMessage): PSoupRequest; cdecl; external; +function soup_message_get_type: TGType; cdecl; external; +function soup_message_get_uri(msg: PSoupMessage): PSoupURI; cdecl; external; +function soup_message_headers_get_content_disposition(hdrs: PSoupMessageHeaders; disposition: PPgchar; params: PPGHashTable): gboolean; cdecl; external; +function soup_message_headers_get_content_length(hdrs: PSoupMessageHeaders): gint64; cdecl; external; +function soup_message_headers_get_content_range(hdrs: PSoupMessageHeaders; start: Pgint64; end_: Pgint64; total_length: Pgint64): gboolean; cdecl; external; +function soup_message_headers_get_content_type(hdrs: PSoupMessageHeaders; params: PPGHashTable): Pgchar; cdecl; external; +function soup_message_headers_get_encoding(hdrs: PSoupMessageHeaders): TSoupEncoding; cdecl; external; +function soup_message_headers_get_expectations(hdrs: PSoupMessageHeaders): TSoupExpectation; cdecl; external; +function soup_message_headers_get_list(hdrs: PSoupMessageHeaders; name: Pgchar): Pgchar; cdecl; external; +function soup_message_headers_get_one(hdrs: PSoupMessageHeaders; name: Pgchar): Pgchar; cdecl; external; +function soup_message_headers_get_ranges(hdrs: PSoupMessageHeaders; total_length: gint64; ranges: PPSoupRange; length: Pgint): gboolean; cdecl; external; +function soup_message_headers_get_type: TGType; cdecl; external; +function soup_message_headers_iter_next(iter: PSoupMessageHeadersIter; name: PPgchar; value: PPgchar): gboolean; cdecl; external; +function soup_message_headers_new(type_: TSoupMessageHeadersType): PSoupMessageHeaders; cdecl; external; +function soup_message_is_keepalive(msg: PSoupMessage): gboolean; cdecl; external; +function soup_message_new(method: Pgchar; uri_string: Pgchar): PSoupMessage; cdecl; external; +function soup_message_new_from_uri(method: Pgchar; uri: PSoupURI): PSoupMessage; cdecl; external; +function soup_multipart_get_length(multipart: PSoupMultipart): gint; cdecl; external; +function soup_multipart_get_part(multipart: PSoupMultipart; part: gint; headers: PPSoupMessageHeaders; body: PPSoupBuffer): gboolean; cdecl; external; +function soup_multipart_get_type: TGType; cdecl; external; +function soup_multipart_input_stream_get_headers(multipart: PSoupMultipartInputStream): PSoupMessageHeaders; cdecl; external; +function soup_multipart_input_stream_get_type: TGType; cdecl; external; +function soup_multipart_input_stream_new(msg: PSoupMessage; base_stream: PGInputStream): PSoupMultipartInputStream; cdecl; external; +function soup_multipart_input_stream_next_part(multipart: PSoupMultipartInputStream; cancellable: PGCancellable; error: PPGError): PGInputStream; cdecl; external; +function soup_multipart_input_stream_next_part_finish(multipart: PSoupMultipartInputStream; result_: PGAsyncResult; error: PPGError): PGInputStream; cdecl; external; +function soup_multipart_new(mime_type: Pgchar): PSoupMultipart; cdecl; external; +function soup_multipart_new_from_message(headers: PSoupMessageHeaders; body: PSoupMessageBody): PSoupMultipart; cdecl; external; +function soup_password_manager_get_type: TGType; cdecl; external; +function soup_proxy_resolver_default_get_type: TGType; cdecl; external; +function soup_proxy_uri_resolver_get_proxy_uri_sync(proxy_uri_resolver: PSoupProxyURIResolver; uri: PSoupURI; cancellable: PGCancellable; proxy_uri: PPSoupURI): guint; cdecl; external; +function soup_proxy_uri_resolver_get_type: TGType; cdecl; external; +function soup_request_data_get_type: TGType; cdecl; external; +function soup_request_error_quark: TGQuark; cdecl; external; +function soup_request_file_get_file(file_: PSoupRequestFile): PGFile; cdecl; external; +function soup_request_file_get_type: TGType; cdecl; external; +function soup_request_get_content_length(request: PSoupRequest): gint64; cdecl; external; +function soup_request_get_content_type(request: PSoupRequest): Pgchar; cdecl; external; +function soup_request_get_session(request: PSoupRequest): PSoupSession; cdecl; external; +function soup_request_get_type: TGType; cdecl; external; +function soup_request_get_uri(request: PSoupRequest): PSoupURI; cdecl; external; +function soup_request_http_get_message(http: PSoupRequestHTTP): PSoupMessage; cdecl; external; +function soup_request_http_get_type: TGType; cdecl; external; +function soup_request_send(request: PSoupRequest; cancellable: PGCancellable; error: PPGError): PGInputStream; cdecl; external; +function soup_request_send_finish(request: PSoupRequest; result_: PGAsyncResult; error: PPGError): PGInputStream; cdecl; external; +function soup_requester_error_quark: TGQuark; cdecl; external; +function soup_requester_get_type: TGType; cdecl; external; +function soup_requester_new: PSoupRequester; cdecl; external; +function soup_requester_request(requester: PSoupRequester; uri_string: Pgchar; error: PPGError): PSoupRequest; cdecl; external; +function soup_requester_request_uri(requester: PSoupRequester; uri: PSoupURI; error: PPGError): PSoupRequest; cdecl; external; +function soup_server_get_async_context(server: PSoupServer): PGMainContext; cdecl; external; +function soup_server_get_listener(server: PSoupServer): PSoupSocket; cdecl; external; +function soup_server_get_port(server: PSoupServer): guint; cdecl; external; +function soup_server_get_type: TGType; cdecl; external; +function soup_server_is_https(server: PSoupServer): gboolean; cdecl; external; +function soup_server_new(optname1: Pgchar; args: array of const): PSoupServer; cdecl; external; +function soup_session_async_get_type: TGType; cdecl; external; +function soup_session_feature_add_feature(feature: PSoupSessionFeature; type_: TGType): gboolean; cdecl; external; +function soup_session_feature_get_type: TGType; cdecl; external; +function soup_session_feature_has_feature(feature: PSoupSessionFeature; type_: TGType): gboolean; cdecl; external; +function soup_session_feature_remove_feature(feature: PSoupSessionFeature; type_: TGType): gboolean; cdecl; external; +function soup_session_get_async_context(session: PSoupSession): PGMainContext; cdecl; external; +function soup_session_get_feature(session: PSoupSession; feature_type: TGType): PSoupSessionFeature; cdecl; external; +function soup_session_get_feature_for_message(session: PSoupSession; feature_type: TGType; msg: PSoupMessage): PSoupSessionFeature; cdecl; external; +function soup_session_get_features(session: PSoupSession; feature_type: TGType): PGSList; cdecl; external; +function soup_session_get_type: TGType; cdecl; external; +function soup_session_has_feature(session: PSoupSession; feature_type: TGType): gboolean; cdecl; external; +function soup_session_new: PSoupSession; cdecl; external; +function soup_session_new_with_options(optname1: Pgchar; args: array of const): PSoupSession; cdecl; external; +function soup_session_redirect_message(session: PSoupSession; msg: PSoupMessage): gboolean; cdecl; external; +function soup_session_request(session: PSoupSession; uri_string: Pgchar; error: PPGError): PSoupRequest; cdecl; external; +function soup_session_request_http(session: PSoupSession; method: Pgchar; uri_string: Pgchar; error: PPGError): PSoupRequestHTTP; cdecl; external; +function soup_session_request_http_uri(session: PSoupSession; method: Pgchar; uri: PSoupURI; error: PPGError): PSoupRequestHTTP; cdecl; external; +function soup_session_request_uri(session: PSoupSession; uri: PSoupURI; error: PPGError): PSoupRequest; cdecl; external; +function soup_session_send(session: PSoupSession; msg: PSoupMessage; cancellable: PGCancellable; error: PPGError): PGInputStream; cdecl; external; +function soup_session_send_finish(session: PSoupSession; result_: PGAsyncResult; error: PPGError): PGInputStream; cdecl; external; +function soup_session_send_message(session: PSoupSession; msg: PSoupMessage): guint; cdecl; external; +function soup_session_sync_get_type: TGType; cdecl; external; +function soup_session_would_redirect(session: PSoupSession; msg: PSoupMessage): gboolean; cdecl; external; +function soup_socket_connect_sync(sock: PSoupSocket; cancellable: PGCancellable): guint; cdecl; external; +function soup_socket_get_fd(sock: PSoupSocket): gint; cdecl; external; +function soup_socket_get_local_address(sock: PSoupSocket): PSoupAddress; cdecl; external; +function soup_socket_get_remote_address(sock: PSoupSocket): PSoupAddress; cdecl; external; +function soup_socket_get_type: TGType; cdecl; external; +function soup_socket_is_connected(sock: PSoupSocket): gboolean; cdecl; external; +function soup_socket_is_ssl(sock: PSoupSocket): gboolean; cdecl; external; +function soup_socket_listen(sock: PSoupSocket): gboolean; cdecl; external; +function soup_socket_new(optname1: Pgchar; args: array of const): PSoupSocket; cdecl; external; +function soup_socket_read(sock: PSoupSocket; buffer: gpointer; len: gsize; nread: Pgsize; cancellable: PGCancellable; error: PPGError): TSoupSocketIOStatus; cdecl; external; +function soup_socket_read_until(sock: PSoupSocket; buffer: gpointer; len: gsize; boundary: Pgpointer; boundary_len: gsize; nread: Pgsize; got_boundary: Pgboolean; cancellable: PGCancellable; error: PPGError): TSoupSocketIOStatus; cdecl; external; +function soup_socket_start_proxy_ssl(sock: PSoupSocket; ssl_host: Pgchar; cancellable: PGCancellable): gboolean; cdecl; external; +function soup_socket_start_ssl(sock: PSoupSocket; cancellable: PGCancellable): gboolean; cdecl; external; +function soup_socket_write(sock: PSoupSocket; buffer: Pgpointer; len: gsize; nwrote: Pgsize; cancellable: PGCancellable; error: PPGError): TSoupSocketIOStatus; cdecl; external; +function soup_status_get_phrase(status_code: guint): Pgchar; cdecl; external; +function soup_status_proxify(status_code: guint): guint; cdecl; external; +function soup_str_case_equal(v1: Pgpointer; v2: Pgpointer): gboolean; cdecl; external; +function soup_str_case_hash(key: Pgpointer): guint; cdecl; external; +function soup_tld_domain_is_public_suffix(domain: Pgchar): gboolean; cdecl; external; +function soup_tld_error_quark: TGQuark; cdecl; external; +function soup_tld_get_base_domain(hostname: Pgchar; error: PPGError): Pgchar; cdecl; external; +function soup_uri_copy(uri: PSoupURI): PSoupURI; cdecl; external; +function soup_uri_copy_host(uri: PSoupURI): PSoupURI; cdecl; external; +function soup_uri_decode(part: Pgchar): Pgchar; cdecl; external; +function soup_uri_encode(part: Pgchar; escape_extra: Pgchar): Pgchar; cdecl; external; +function soup_uri_equal(uri1: PSoupURI; uri2: PSoupURI): gboolean; cdecl; external; +function soup_uri_get_fragment(uri: PSoupURI): Pgchar; cdecl; external; +function soup_uri_get_host(uri: PSoupURI): Pgchar; cdecl; external; +function soup_uri_get_password(uri: PSoupURI): Pgchar; cdecl; external; +function soup_uri_get_path(uri: PSoupURI): Pgchar; cdecl; external; +function soup_uri_get_port(uri: PSoupURI): guint; cdecl; external; +function soup_uri_get_query(uri: PSoupURI): Pgchar; cdecl; external; +function soup_uri_get_scheme(uri: PSoupURI): Pgchar; cdecl; external; +function soup_uri_get_type: TGType; cdecl; external; +function soup_uri_get_user(uri: PSoupURI): Pgchar; cdecl; external; +function soup_uri_host_equal(v1: PSoupURI; v2: PSoupURI): gboolean; cdecl; external; +function soup_uri_host_hash(key: PSoupURI): guint; cdecl; external; +function soup_uri_new(uri_string: Pgchar): PSoupURI; cdecl; external; +function soup_uri_new_with_base(base: PSoupURI; uri_string: Pgchar): PSoupURI; cdecl; external; +function soup_uri_normalize(part: Pgchar; unescape_extra: Pgchar): Pgchar; cdecl; external; +function soup_uri_to_string(uri: PSoupURI; just_path_and_query: gboolean): Pgchar; cdecl; external; +function soup_uri_uses_default_port(uri: PSoupURI): gboolean; cdecl; external; +function soup_value_array_from_args(args: Tva_list): PGValueArray; cdecl; external; +function soup_value_array_get_nth(array_: PGValueArray; index_: guint; type_: TGType; args: array of const): gboolean; cdecl; external; +function soup_value_array_new: PGValueArray; cdecl; external; +function soup_value_array_new_with_vals(first_type: TGType; args: array of const): PGValueArray; cdecl; external; +function soup_value_array_to_args(array_: PGValueArray; args: Tva_list): gboolean; cdecl; external; +function soup_value_hash_lookup(hash: PGHashTable; key: Pgchar; type_: TGType; args: array of const): gboolean; cdecl; external; +function soup_value_hash_lookup_vals(hash: PGHashTable; first_key: Pgchar; args: array of const): gboolean; cdecl; external; +function soup_value_hash_new: PGHashTable; cdecl; external; +function soup_value_hash_new_with_vals(first_key: Pgchar; args: array of const): PGHashTable; cdecl; external; +function soup_xmlrpc_build_fault(fault_code: gint; fault_format: Pgchar; args: array of const): Pgchar; cdecl; external; +function soup_xmlrpc_build_method_call(method_name: Pgchar; params: PGValue; n_params: gint): Pgchar; cdecl; external; +function soup_xmlrpc_build_method_response(value: PGValue): Pgchar; cdecl; external; +function soup_xmlrpc_error_quark: TGQuark; cdecl; external; +function soup_xmlrpc_extract_method_call(method_call: Pgchar; length: gint; method_name: PPgchar; args: array of const): gboolean; cdecl; external; +function soup_xmlrpc_extract_method_response(method_response: Pgchar; length: gint; error: PPGError; type_: TGType; args: array of const): gboolean; cdecl; external; +function soup_xmlrpc_fault_quark: TGQuark; cdecl; external; +function soup_xmlrpc_parse_method_call(method_call: Pgchar; length: gint; method_name: PPgchar; params: PPGValueArray): gboolean; cdecl; external; +function soup_xmlrpc_parse_method_response(method_response: Pgchar; length: gint; value: PGValue; error: PPGError): gboolean; cdecl; external; +function soup_xmlrpc_request_new(uri: Pgchar; method_name: Pgchar; args: array of const): PSoupMessage; cdecl; external; +procedure soup_address_resolve_async(addr: PSoupAddress; async_context: PGMainContext; cancellable: PGCancellable; callback: TSoupAddressCallback; user_data: gpointer); cdecl; external; +procedure soup_auth_authenticate(auth: PSoupAuth; username: Pgchar; password: Pgchar); cdecl; external; +procedure soup_auth_domain_add_path(domain: PSoupAuthDomain; path: Pgchar); cdecl; external; +procedure soup_auth_domain_basic_set_auth_callback(domain: PSoupAuthDomain; callback: TSoupAuthDomainBasicAuthCallback; user_data: gpointer; dnotify: TGDestroyNotify); cdecl; external; +procedure soup_auth_domain_challenge(domain: PSoupAuthDomain; msg: PSoupMessage); cdecl; external; +procedure soup_auth_domain_digest_set_auth_callback(domain: PSoupAuthDomain; callback: TSoupAuthDomainDigestAuthCallback; user_data: gpointer; dnotify: TGDestroyNotify); cdecl; external; +procedure soup_auth_domain_remove_path(domain: PSoupAuthDomain; path: Pgchar); cdecl; external; +procedure soup_auth_domain_set_filter(domain: PSoupAuthDomain; filter: TSoupAuthDomainFilter; filter_data: gpointer; dnotify: TGDestroyNotify); cdecl; external; +procedure soup_auth_domain_set_generic_auth_callback(domain: PSoupAuthDomain; auth_callback: TSoupAuthDomainGenericAuthCallback; auth_data: gpointer; dnotify: TGDestroyNotify); cdecl; external; +procedure soup_auth_free_protection_space(auth: PSoupAuth; space: PGSList); cdecl; external; +procedure soup_auth_has_saved_password(auth: PSoupAuth; username: Pgchar; password: Pgchar); cdecl; external; +procedure soup_auth_manager_use_auth(manager: PSoupAuthManager; uri: PSoupURI; auth: PSoupAuth); cdecl; external; +procedure soup_auth_save_password(auth: PSoupAuth; username: Pgchar; password: Pgchar); cdecl; external; +procedure soup_buffer_free(buffer: PSoupBuffer); cdecl; external; +procedure soup_buffer_get_data(buffer: PSoupBuffer; data: PPguint8; length: Pgsize); cdecl; external; +procedure soup_cache_clear(cache: PSoupCache); cdecl; external; +procedure soup_cache_dump(cache: PSoupCache); cdecl; external; +procedure soup_cache_flush(cache: PSoupCache); cdecl; external; +procedure soup_cache_load(cache: PSoupCache); cdecl; external; +procedure soup_cache_set_max_size(cache: PSoupCache; max_size: guint); cdecl; external; +procedure soup_cookie_free(cookie: PSoupCookie); cdecl; external; +procedure soup_cookie_jar_add_cookie(jar: PSoupCookieJar; cookie: PSoupCookie); cdecl; external; +procedure soup_cookie_jar_add_cookie_with_first_party(jar: PSoupCookieJar; first_party: PSoupURI; cookie: PSoupCookie); cdecl; external; +procedure soup_cookie_jar_delete_cookie(jar: PSoupCookieJar; cookie: PSoupCookie); cdecl; external; +procedure soup_cookie_jar_set_accept_policy(jar: PSoupCookieJar; policy: TSoupCookieJarAcceptPolicy); cdecl; external; +procedure soup_cookie_jar_set_cookie(jar: PSoupCookieJar; uri: PSoupURI; cookie: Pgchar); cdecl; external; +procedure soup_cookie_jar_set_cookie_with_first_party(jar: PSoupCookieJar; uri: PSoupURI; first_party: PSoupURI; cookie: Pgchar); cdecl; external; +procedure soup_cookie_set_domain(cookie: PSoupCookie; domain: Pgchar); cdecl; external; +procedure soup_cookie_set_expires(cookie: PSoupCookie; expires: PSoupDate); cdecl; external; +procedure soup_cookie_set_http_only(cookie: PSoupCookie; http_only: gboolean); cdecl; external; +procedure soup_cookie_set_max_age(cookie: PSoupCookie; max_age: gint); cdecl; external; +procedure soup_cookie_set_name(cookie: PSoupCookie; name: Pgchar); cdecl; external; +procedure soup_cookie_set_path(cookie: PSoupCookie; path: Pgchar); cdecl; external; +procedure soup_cookie_set_secure(cookie: PSoupCookie; secure: gboolean); cdecl; external; +procedure soup_cookie_set_value(cookie: PSoupCookie; value: Pgchar); cdecl; external; +procedure soup_cookies_free(cookies: PGSList); cdecl; external; +procedure soup_cookies_to_request(cookies: PGSList; msg: PSoupMessage); cdecl; external; +procedure soup_cookies_to_response(cookies: PGSList; msg: PSoupMessage); cdecl; external; +procedure soup_date_free(date: PSoupDate); cdecl; external; +procedure soup_date_to_timeval(date: PSoupDate; time: PGTimeVal); cdecl; external; +procedure soup_header_free_list(list: PGSList); cdecl; external; +procedure soup_header_free_param_list(param_list: PGHashTable); cdecl; external; +procedure soup_header_g_string_append_param(string_: PGString; name: Pgchar; value: Pgchar); cdecl; external; +procedure soup_header_g_string_append_param_quoted(string_: PGString; name: Pgchar; value: Pgchar); cdecl; external; +procedure soup_logger_set_printer(logger: PSoupLogger; printer: TSoupLoggerPrinter; printer_data: gpointer; destroy_: TGDestroyNotify); cdecl; external; +procedure soup_logger_set_request_filter(logger: PSoupLogger; request_filter: TSoupLoggerFilter; filter_data: gpointer; destroy_: TGDestroyNotify); cdecl; external; +procedure soup_logger_set_response_filter(logger: PSoupLogger; response_filter: TSoupLoggerFilter; filter_data: gpointer; destroy_: TGDestroyNotify); cdecl; external; +procedure soup_message_body_append(body: PSoupMessageBody; use: TSoupMemoryUse; data: guint8; length: gsize); cdecl; external; +procedure soup_message_body_append_buffer(body: PSoupMessageBody; buffer: PSoupBuffer); cdecl; external; +procedure soup_message_body_append_take(body: PSoupMessageBody; data: Pguint8; length: gsize); cdecl; external; +procedure soup_message_body_complete(body: PSoupMessageBody); cdecl; external; +procedure soup_message_body_free(body: PSoupMessageBody); cdecl; external; +procedure soup_message_body_got_chunk(body: PSoupMessageBody; chunk: PSoupBuffer); cdecl; external; +procedure soup_message_body_set_accumulate(body: PSoupMessageBody; accumulate: gboolean); cdecl; external; +procedure soup_message_body_truncate(body: PSoupMessageBody); cdecl; external; +procedure soup_message_body_wrote_chunk(body: PSoupMessageBody; chunk: PSoupBuffer); cdecl; external; +procedure soup_message_content_sniffed(msg: PSoupMessage; content_type: Pgchar; params: PGHashTable); cdecl; external; +procedure soup_message_disable_feature(msg: PSoupMessage; feature_type: TGType); cdecl; external; +procedure soup_message_finished(msg: PSoupMessage); cdecl; external; +procedure soup_message_got_body(msg: PSoupMessage); cdecl; external; +procedure soup_message_got_chunk(msg: PSoupMessage; chunk: PSoupBuffer); cdecl; external; +procedure soup_message_got_headers(msg: PSoupMessage); cdecl; external; +procedure soup_message_got_informational(msg: PSoupMessage); cdecl; external; +procedure soup_message_headers_append(hdrs: PSoupMessageHeaders; name: Pgchar; value: Pgchar); cdecl; external; +procedure soup_message_headers_clean_connection_headers(hdrs: PSoupMessageHeaders); cdecl; external; +procedure soup_message_headers_clear(hdrs: PSoupMessageHeaders); cdecl; external; +procedure soup_message_headers_foreach(hdrs: PSoupMessageHeaders; func: TSoupMessageHeadersForeachFunc; user_data: gpointer); cdecl; external; +procedure soup_message_headers_free(hdrs: PSoupMessageHeaders); cdecl; external; +procedure soup_message_headers_free_ranges(hdrs: PSoupMessageHeaders; ranges: PSoupRange); cdecl; external; +procedure soup_message_headers_iter_init(iter: PSoupMessageHeadersIter; hdrs: PSoupMessageHeaders); cdecl; external; +procedure soup_message_headers_remove(hdrs: PSoupMessageHeaders; name: Pgchar); cdecl; external; +procedure soup_message_headers_replace(hdrs: PSoupMessageHeaders; name: Pgchar; value: Pgchar); cdecl; external; +procedure soup_message_headers_set_content_disposition(hdrs: PSoupMessageHeaders; disposition: Pgchar; params: PGHashTable); cdecl; external; +procedure soup_message_headers_set_content_length(hdrs: PSoupMessageHeaders; content_length: gint64); cdecl; external; +procedure soup_message_headers_set_content_range(hdrs: PSoupMessageHeaders; start: gint64; end_: gint64; total_length: gint64); cdecl; external; +procedure soup_message_headers_set_content_type(hdrs: PSoupMessageHeaders; content_type: Pgchar; params: PGHashTable); cdecl; external; +procedure soup_message_headers_set_encoding(hdrs: PSoupMessageHeaders; encoding: TSoupEncoding); cdecl; external; +procedure soup_message_headers_set_expectations(hdrs: PSoupMessageHeaders; expectations: TSoupExpectation); cdecl; external; +procedure soup_message_headers_set_range(hdrs: PSoupMessageHeaders; start: gint64; end_: gint64); cdecl; external; +procedure soup_message_headers_set_ranges(hdrs: PSoupMessageHeaders; ranges: PSoupRange; length: gint); cdecl; external; +procedure soup_message_restarted(msg: PSoupMessage); cdecl; external; +procedure soup_message_set_first_party(msg: PSoupMessage; first_party: PSoupURI); cdecl; external; +procedure soup_message_set_flags(msg: PSoupMessage; flags: TSoupMessageFlags); cdecl; external; +procedure soup_message_set_http_version(msg: PSoupMessage; version: TSoupHTTPVersion); cdecl; external; +procedure soup_message_set_redirect(msg: PSoupMessage; status_code: guint; redirect_uri: Pgchar); cdecl; external; +procedure soup_message_set_request(msg: PSoupMessage; content_type: Pgchar; req_use: TSoupMemoryUse; req_body: Pgchar; req_length: gsize); cdecl; external; +procedure soup_message_set_response(msg: PSoupMessage; content_type: Pgchar; resp_use: TSoupMemoryUse; resp_body: Pgchar; resp_length: gsize); cdecl; external; +procedure soup_message_set_status(msg: PSoupMessage; status_code: guint); cdecl; external; +procedure soup_message_set_status_full(msg: PSoupMessage; status_code: guint; reason_phrase: Pgchar); cdecl; external; +procedure soup_message_set_uri(msg: PSoupMessage; uri: PSoupURI); cdecl; external; +procedure soup_message_wrote_body(msg: PSoupMessage); cdecl; external; +procedure soup_message_wrote_body_data(msg: PSoupMessage; chunk: PSoupBuffer); cdecl; external; +procedure soup_message_wrote_chunk(msg: PSoupMessage); cdecl; external; +procedure soup_message_wrote_headers(msg: PSoupMessage); cdecl; external; +procedure soup_message_wrote_informational(msg: PSoupMessage); cdecl; external; +procedure soup_multipart_append_form_file(multipart: PSoupMultipart; control_name: Pgchar; filename: Pgchar; content_type: Pgchar; body: PSoupBuffer); cdecl; external; +procedure soup_multipart_append_form_string(multipart: PSoupMultipart; control_name: Pgchar; data: Pgchar); cdecl; external; +procedure soup_multipart_append_part(multipart: PSoupMultipart; headers: PSoupMessageHeaders; body: PSoupBuffer); cdecl; external; +procedure soup_multipart_free(multipart: PSoupMultipart); cdecl; external; +procedure soup_multipart_input_stream_next_part_async(multipart: PSoupMultipartInputStream; io_priority: gint; cancellable: PGCancellable; callback: TGAsyncReadyCallback; data: gpointer); cdecl; external; +procedure soup_multipart_to_message(multipart: PSoupMultipart; dest_headers: PSoupMessageHeaders; dest_body: PSoupMessageBody); cdecl; external; +procedure soup_password_manager_get_passwords_async(password_manager: PSoupPasswordManager; msg: PSoupMessage; auth: PSoupAuth; retrying: gboolean; async_context: PGMainContext; cancellable: PGCancellable; callback: TSoupPasswordManagerCallback; user_data: gpointer); cdecl; external; +procedure soup_password_manager_get_passwords_sync(password_manager: PSoupPasswordManager; msg: PSoupMessage; auth: PSoupAuth; cancellable: PGCancellable); cdecl; external; +procedure soup_proxy_uri_resolver_get_proxy_uri_async(proxy_uri_resolver: PSoupProxyURIResolver; uri: PSoupURI; async_context: PGMainContext; cancellable: PGCancellable; callback: TSoupProxyURIResolverCallback; user_data: gpointer); cdecl; external; +procedure soup_request_send_async(request: PSoupRequest; cancellable: PGCancellable; callback: TGAsyncReadyCallback; user_data: gpointer); cdecl; external; +procedure soup_server_add_auth_domain(server: PSoupServer; auth_domain: PSoupAuthDomain); cdecl; external; +procedure soup_server_add_handler(server: PSoupServer; path: Pgchar; callback: TSoupServerCallback; user_data: gpointer; destroy_: TGDestroyNotify); cdecl; external; +procedure soup_server_disconnect(server: PSoupServer); cdecl; external; +procedure soup_server_pause_message(server: PSoupServer; msg: PSoupMessage); cdecl; external; +procedure soup_server_quit(server: PSoupServer); cdecl; external; +procedure soup_server_remove_auth_domain(server: PSoupServer; auth_domain: PSoupAuthDomain); cdecl; external; +procedure soup_server_remove_handler(server: PSoupServer; path: Pgchar); cdecl; external; +procedure soup_server_run(server: PSoupServer); cdecl; external; +procedure soup_server_run_async(server: PSoupServer); cdecl; external; +procedure soup_server_unpause_message(server: PSoupServer; msg: PSoupMessage); cdecl; external; +procedure soup_session_abort(session: PSoupSession); cdecl; external; +procedure soup_session_add_feature(session: PSoupSession; feature: PSoupSessionFeature); cdecl; external; +procedure soup_session_add_feature_by_type(session: PSoupSession; feature_type: TGType); cdecl; external; +procedure soup_session_cancel_message(session: PSoupSession; msg: PSoupMessage; status_code: guint); cdecl; external; +procedure soup_session_feature_attach(feature: PSoupSessionFeature; session: PSoupSession); cdecl; external; +procedure soup_session_feature_detach(feature: PSoupSessionFeature; session: PSoupSession); cdecl; external; +procedure soup_session_pause_message(session: PSoupSession; msg: PSoupMessage); cdecl; external; +procedure soup_session_prefetch_dns(session: PSoupSession; hostname: Pgchar; cancellable: PGCancellable; callback: TSoupAddressCallback; user_data: gpointer); cdecl; external; +procedure soup_session_queue_message(session: PSoupSession; msg: PSoupMessage; callback: TSoupSessionCallback; user_data: gpointer); cdecl; external; +procedure soup_session_remove_feature(session: PSoupSession; feature: PSoupSessionFeature); cdecl; external; +procedure soup_session_remove_feature_by_type(session: PSoupSession; feature_type: TGType); cdecl; external; +procedure soup_session_requeue_message(session: PSoupSession; msg: PSoupMessage); cdecl; external; +procedure soup_session_send_async(session: PSoupSession; msg: PSoupMessage; cancellable: PGCancellable; callback: TGAsyncReadyCallback; user_data: gpointer); cdecl; external; +procedure soup_session_unpause_message(session: PSoupSession; msg: PSoupMessage); cdecl; external; +procedure soup_socket_connect_async(sock: PSoupSocket; cancellable: PGCancellable; callback: TSoupSocketCallback; user_data: gpointer); cdecl; external; +procedure soup_socket_disconnect(sock: PSoupSocket); cdecl; external; +procedure soup_uri_free(uri: PSoupURI); cdecl; external; +procedure soup_uri_set_fragment(uri: PSoupURI; fragment: Pgchar); cdecl; external; +procedure soup_uri_set_host(uri: PSoupURI; host: Pgchar); cdecl; external; +procedure soup_uri_set_password(uri: PSoupURI; password: Pgchar); cdecl; external; +procedure soup_uri_set_path(uri: PSoupURI; path: Pgchar); cdecl; external; +procedure soup_uri_set_port(uri: PSoupURI; port: guint); cdecl; external; +procedure soup_uri_set_query(uri: PSoupURI; query: Pgchar); cdecl; external; +procedure soup_uri_set_query_from_fields(uri: PSoupURI; first_field: Pgchar; args: array of const); cdecl; external; +procedure soup_uri_set_query_from_form(uri: PSoupURI; form: PGHashTable); cdecl; external; +procedure soup_uri_set_scheme(uri: PSoupURI; scheme: Pgchar); cdecl; external; +procedure soup_uri_set_user(uri: PSoupURI; user: Pgchar); cdecl; external; +procedure soup_value_array_append(array_: PGValueArray; type_: TGType; args: array of const); cdecl; external; +procedure soup_value_array_append_vals(array_: PGValueArray; first_type: TGType; args: array of const); cdecl; external; +procedure soup_value_array_insert(array_: PGValueArray; index_: guint; type_: TGType; args: array of const); cdecl; external; +procedure soup_value_hash_insert(hash: PGHashTable; key: Pgchar; type_: TGType; args: array of const); cdecl; external; +procedure soup_value_hash_insert_vals(hash: PGHashTable; first_key: Pgchar; args: array of const); cdecl; external; +procedure soup_value_hash_insert_value(hash: PGHashTable; key: Pgchar; value: PGValue); cdecl; external; +procedure soup_xmlrpc_set_fault(msg: PSoupMessage; fault_code: gint; fault_format: Pgchar; args: array of const); cdecl; external; +procedure soup_xmlrpc_set_response(msg: PSoupMessage; type_: TGType; args: array of const); cdecl; external; +implementation +function TSoupAddress.new(name: Pgchar; port: guint): PSoupAddress; cdecl; +begin + Result := LazSoup2_4.soup_address_new(name, port); +end; + +function TSoupAddress.new_any(family: TSoupAddressFamily; port: guint): PSoupAddress; cdecl; +begin + Result := LazSoup2_4.soup_address_new_any(family, port); +end; + +function TSoupAddress.new_from_sockaddr(sa: Pgpointer; len: gint): PSoupAddress; cdecl; +begin + Result := LazSoup2_4.soup_address_new_from_sockaddr(sa, len); +end; + +function TSoupAddress.equal_by_ip(addr2: PSoupAddress): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_address_equal_by_ip(@self, addr2); +end; + +function TSoupAddress.equal_by_name(addr2: PSoupAddress): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_address_equal_by_name(@self, addr2); +end; + +function TSoupAddress.get_gsockaddr: PGSocketAddress; cdecl; +begin + Result := LazSoup2_4.soup_address_get_gsockaddr(@self); +end; + +function TSoupAddress.get_name: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_address_get_name(@self); +end; + +function TSoupAddress.get_physical: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_address_get_physical(@self); +end; + +function TSoupAddress.get_port: guint; cdecl; +begin + Result := LazSoup2_4.soup_address_get_port(@self); +end; + +function TSoupAddress.get_sockaddr(len: Pgint): Pgpointer; cdecl; +begin + Result := LazSoup2_4.soup_address_get_sockaddr(@self, len); +end; + +function TSoupAddress.hash_by_ip: guint; cdecl; +begin + Result := LazSoup2_4.soup_address_hash_by_ip(@self); +end; + +function TSoupAddress.hash_by_name: guint; cdecl; +begin + Result := LazSoup2_4.soup_address_hash_by_name(@self); +end; + +function TSoupAddress.is_resolved: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_address_is_resolved(@self); +end; + +procedure TSoupAddress.resolve_async(async_context: PGMainContext; cancellable: PGCancellable; callback: TSoupAddressCallback; user_data: gpointer); cdecl; +begin + LazSoup2_4.soup_address_resolve_async(@self, async_context, cancellable, callback, user_data); +end; + +function TSoupAddress.resolve_sync(cancellable: PGCancellable): guint; cdecl; +begin + Result := LazSoup2_4.soup_address_resolve_sync(@self, cancellable); +end; + +function TSoupAuth.new(type_: TGType; msg: PSoupMessage; auth_header: Pgchar): PSoupAuth; cdecl; +begin + Result := LazSoup2_4.soup_auth_new(type_, msg, auth_header); +end; + +procedure TSoupAuth.authenticate(username: Pgchar; password: Pgchar); cdecl; +begin + LazSoup2_4.soup_auth_authenticate(@self, username, password); +end; + +procedure TSoupAuth.free_protection_space(space: PGSList); cdecl; +begin + LazSoup2_4.soup_auth_free_protection_space(@self, space); +end; + +function TSoupAuth.get_authorization(msg: PSoupMessage): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_auth_get_authorization(@self, msg); +end; + +function TSoupAuth.get_host: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_auth_get_host(@self); +end; + +function TSoupAuth.get_info: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_auth_get_info(@self); +end; + +function TSoupAuth.get_protection_space(source_uri: PSoupURI): PGSList; cdecl; +begin + Result := LazSoup2_4.soup_auth_get_protection_space(@self, source_uri); +end; + +function TSoupAuth.get_realm: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_auth_get_realm(@self); +end; + +function TSoupAuth.get_saved_password(user: Pgchar): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_auth_get_saved_password(@self, user); +end; + +function TSoupAuth.get_saved_users: PGSList; cdecl; +begin + Result := LazSoup2_4.soup_auth_get_saved_users(@self); +end; + +function TSoupAuth.get_scheme_name: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_auth_get_scheme_name(@self); +end; + +procedure TSoupAuth.has_saved_password(username: Pgchar; password: Pgchar); cdecl; +begin + LazSoup2_4.soup_auth_has_saved_password(@self, username, password); +end; + +function TSoupAuth.is_authenticated: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_auth_is_authenticated(@self); +end; + +function TSoupAuth.is_for_proxy: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_auth_is_for_proxy(@self); +end; + +function TSoupAuth.is_ready(msg: PSoupMessage): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_auth_is_ready(@self, msg); +end; + +procedure TSoupAuth.save_password(username: Pgchar; password: Pgchar); cdecl; +begin + LazSoup2_4.soup_auth_save_password(@self, username, password); +end; + +function TSoupAuth.update(msg: PSoupMessage; auth_header: Pgchar): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_auth_update(@self, msg, auth_header); +end; + +function TSoupMessage.new(method: Pgchar; uri_string: Pgchar): PSoupMessage; cdecl; +begin + Result := LazSoup2_4.soup_message_new(method, uri_string); +end; + +function TSoupMessage.new_from_uri(method: Pgchar; uri: PSoupURI): PSoupMessage; cdecl; +begin + Result := LazSoup2_4.soup_message_new_from_uri(method, uri); +end; + +function TSoupMessage.add_header_handler(signal: Pgchar; header: Pgchar; callback: TGCallback; user_data: gpointer): guint; cdecl; +begin + Result := LazSoup2_4.soup_message_add_header_handler(@self, signal, header, callback, user_data); +end; + +function TSoupMessage.add_status_code_handler(signal: Pgchar; status_code: guint; callback: TGCallback; user_data: gpointer): guint; cdecl; +begin + Result := LazSoup2_4.soup_message_add_status_code_handler(@self, signal, status_code, callback, user_data); +end; + +procedure TSoupMessage.content_sniffed(content_type: Pgchar; params: PGHashTable); cdecl; +begin + LazSoup2_4.soup_message_content_sniffed(@self, content_type, params); +end; + +procedure TSoupMessage.disable_feature(feature_type: TGType); cdecl; +begin + LazSoup2_4.soup_message_disable_feature(@self, feature_type); +end; + +procedure TSoupMessage.finished; cdecl; +begin + LazSoup2_4.soup_message_finished(@self); +end; + +function TSoupMessage.get_address: PSoupAddress; cdecl; +begin + Result := LazSoup2_4.soup_message_get_address(@self); +end; + +function TSoupMessage.get_first_party: PSoupURI; cdecl; +begin + Result := LazSoup2_4.soup_message_get_first_party(@self); +end; + +function TSoupMessage.get_flags: TSoupMessageFlags; cdecl; +begin + Result := LazSoup2_4.soup_message_get_flags(@self); +end; + +function TSoupMessage.get_http_version: TSoupHTTPVersion; cdecl; +begin + Result := LazSoup2_4.soup_message_get_http_version(@self); +end; + +function TSoupMessage.get_https_status(certificate: PPGTlsCertificate; errors: PGTlsCertificateFlags): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_message_get_https_status(@self, certificate, errors); +end; + +function TSoupMessage.get_soup_request: PSoupRequest; cdecl; +begin + Result := LazSoup2_4.soup_message_get_soup_request(@self); +end; + +function TSoupMessage.get_uri: PSoupURI; cdecl; +begin + Result := LazSoup2_4.soup_message_get_uri(@self); +end; + +procedure TSoupMessage.got_body; cdecl; +begin + LazSoup2_4.soup_message_got_body(@self); +end; + +procedure TSoupMessage.got_chunk(chunk: PSoupBuffer); cdecl; +begin + LazSoup2_4.soup_message_got_chunk(@self, chunk); +end; + +procedure TSoupMessage.got_headers; cdecl; +begin + LazSoup2_4.soup_message_got_headers(@self); +end; + +procedure TSoupMessage.got_informational; cdecl; +begin + LazSoup2_4.soup_message_got_informational(@self); +end; + +function TSoupMessage.is_keepalive: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_message_is_keepalive(@self); +end; + +procedure TSoupMessage.restarted; cdecl; +begin + LazSoup2_4.soup_message_restarted(@self); +end; + +procedure TSoupMessage.set_first_party(first_party: PSoupURI); cdecl; +begin + LazSoup2_4.soup_message_set_first_party(@self, first_party); +end; + +procedure TSoupMessage.set_flags(flags: TSoupMessageFlags); cdecl; +begin + LazSoup2_4.soup_message_set_flags(@self, flags); +end; + +procedure TSoupMessage.set_http_version(version: TSoupHTTPVersion); cdecl; +begin + LazSoup2_4.soup_message_set_http_version(@self, version); +end; + +procedure TSoupMessage.set_redirect(status_code: guint; redirect_uri: Pgchar); cdecl; +begin + LazSoup2_4.soup_message_set_redirect(@self, status_code, redirect_uri); +end; + +procedure TSoupMessage.set_request(content_type: Pgchar; req_use: TSoupMemoryUse; req_body: Pgchar; req_length: gsize); cdecl; +begin + LazSoup2_4.soup_message_set_request(@self, content_type, req_use, req_body, req_length); +end; + +procedure TSoupMessage.set_response(content_type: Pgchar; resp_use: TSoupMemoryUse; resp_body: Pgchar; resp_length: gsize); cdecl; +begin + LazSoup2_4.soup_message_set_response(@self, content_type, resp_use, resp_body, resp_length); +end; + +procedure TSoupMessage.set_status(status_code: guint); cdecl; +begin + LazSoup2_4.soup_message_set_status(@self, status_code); +end; + +procedure TSoupMessage.set_status_full(status_code: guint; reason_phrase: Pgchar); cdecl; +begin + LazSoup2_4.soup_message_set_status_full(@self, status_code, reason_phrase); +end; + +procedure TSoupMessage.set_uri(uri: PSoupURI); cdecl; +begin + LazSoup2_4.soup_message_set_uri(@self, uri); +end; + +procedure TSoupMessage.wrote_body; cdecl; +begin + LazSoup2_4.soup_message_wrote_body(@self); +end; + +procedure TSoupMessage.wrote_body_data(chunk: PSoupBuffer); cdecl; +begin + LazSoup2_4.soup_message_wrote_body_data(@self, chunk); +end; + +procedure TSoupMessage.wrote_chunk; cdecl; +begin + LazSoup2_4.soup_message_wrote_chunk(@self); +end; + +procedure TSoupMessage.wrote_headers; cdecl; +begin + LazSoup2_4.soup_message_wrote_headers(@self); +end; + +procedure TSoupMessage.wrote_informational; cdecl; +begin + LazSoup2_4.soup_message_wrote_informational(@self); +end; + +function TSoupURI.new(uri_string: Pgchar): PSoupURI; cdecl; +begin + Result := LazSoup2_4.soup_uri_new(uri_string); +end; + +function TSoupURI.copy: PSoupURI; cdecl; +begin + Result := LazSoup2_4.soup_uri_copy(@self); +end; + +function TSoupURI.copy_host: PSoupURI; cdecl; +begin + Result := LazSoup2_4.soup_uri_copy_host(@self); +end; + +function TSoupURI.equal(uri2: PSoupURI): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_uri_equal(@self, uri2); +end; + +procedure TSoupURI.free; cdecl; +begin + LazSoup2_4.soup_uri_free(@self); +end; + +function TSoupURI.get_fragment: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_uri_get_fragment(@self); +end; + +function TSoupURI.get_host: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_uri_get_host(@self); +end; + +function TSoupURI.get_password: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_uri_get_password(@self); +end; + +function TSoupURI.get_path: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_uri_get_path(@self); +end; + +function TSoupURI.get_port: guint; cdecl; +begin + Result := LazSoup2_4.soup_uri_get_port(@self); +end; + +function TSoupURI.get_query: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_uri_get_query(@self); +end; + +function TSoupURI.get_scheme: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_uri_get_scheme(@self); +end; + +function TSoupURI.get_user: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_uri_get_user(@self); +end; + +function TSoupURI.host_equal(v2: PSoupURI): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_uri_host_equal(@self, v2); +end; + +function TSoupURI.host_hash: guint; cdecl; +begin + Result := LazSoup2_4.soup_uri_host_hash(@self); +end; + +function TSoupURI.new_with_base(uri_string: Pgchar): PSoupURI; cdecl; +begin + Result := LazSoup2_4.soup_uri_new_with_base(@self, uri_string); +end; + +procedure TSoupURI.set_fragment(fragment: Pgchar); cdecl; +begin + LazSoup2_4.soup_uri_set_fragment(@self, fragment); +end; + +procedure TSoupURI.set_host(host: Pgchar); cdecl; +begin + LazSoup2_4.soup_uri_set_host(@self, host); +end; + +procedure TSoupURI.set_password(password: Pgchar); cdecl; +begin + LazSoup2_4.soup_uri_set_password(@self, password); +end; + +procedure TSoupURI.set_path(path: Pgchar); cdecl; +begin + LazSoup2_4.soup_uri_set_path(@self, path); +end; + +procedure TSoupURI.set_port(port: guint); cdecl; +begin + LazSoup2_4.soup_uri_set_port(@self, port); +end; + +procedure TSoupURI.set_query(query: Pgchar); cdecl; +begin + LazSoup2_4.soup_uri_set_query(@self, query); +end; + +procedure TSoupURI.set_query_from_form(form: PGHashTable); cdecl; +begin + LazSoup2_4.soup_uri_set_query_from_form(@self, form); +end; + +procedure TSoupURI.set_scheme(scheme: Pgchar); cdecl; +begin + LazSoup2_4.soup_uri_set_scheme(@self, scheme); +end; + +procedure TSoupURI.set_user(user: Pgchar); cdecl; +begin + LazSoup2_4.soup_uri_set_user(@self, user); +end; + +function TSoupURI.to_string(just_path_and_query: gboolean): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_uri_to_string(@self, just_path_and_query); +end; + +function TSoupURI.uses_default_port: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_uri_uses_default_port(@self); +end; + +function TSoupURI.decode(part: Pgchar): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_uri_decode(part); +end; + +function TSoupURI.encode(part: Pgchar; escape_extra: Pgchar): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_uri_encode(part, escape_extra); +end; + +function TSoupURI.normalize(part: Pgchar; unescape_extra: Pgchar): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_uri_normalize(part, unescape_extra); +end; + +function TSoupAuthDomain.accepts(msg: PSoupMessage): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_auth_domain_accepts(@self, msg); +end; + +procedure TSoupAuthDomain.add_path(path: Pgchar); cdecl; +begin + LazSoup2_4.soup_auth_domain_add_path(@self, path); +end; + +procedure TSoupAuthDomain.basic_set_auth_callback(callback: TSoupAuthDomainBasicAuthCallback; user_data: gpointer; dnotify: TGDestroyNotify); cdecl; +begin + LazSoup2_4.soup_auth_domain_basic_set_auth_callback(@self, callback, user_data, dnotify); +end; + +procedure TSoupAuthDomain.challenge(msg: PSoupMessage); cdecl; +begin + LazSoup2_4.soup_auth_domain_challenge(@self, msg); +end; + +function TSoupAuthDomain.check_password(msg: PSoupMessage; username: Pgchar; password: Pgchar): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_auth_domain_check_password(@self, msg, username, password); +end; + +function TSoupAuthDomain.covers(msg: PSoupMessage): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_auth_domain_covers(@self, msg); +end; + +procedure TSoupAuthDomain.digest_set_auth_callback(callback: TSoupAuthDomainDigestAuthCallback; user_data: gpointer; dnotify: TGDestroyNotify); cdecl; +begin + LazSoup2_4.soup_auth_domain_digest_set_auth_callback(@self, callback, user_data, dnotify); +end; + +function TSoupAuthDomain.get_realm: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_auth_domain_get_realm(@self); +end; + +procedure TSoupAuthDomain.remove_path(path: Pgchar); cdecl; +begin + LazSoup2_4.soup_auth_domain_remove_path(@self, path); +end; + +procedure TSoupAuthDomain.set_filter(filter: TSoupAuthDomainFilter; filter_data: gpointer; dnotify: TGDestroyNotify); cdecl; +begin + LazSoup2_4.soup_auth_domain_set_filter(@self, filter, filter_data, dnotify); +end; + +procedure TSoupAuthDomain.set_generic_auth_callback(auth_callback: TSoupAuthDomainGenericAuthCallback; auth_data: gpointer; dnotify: TGDestroyNotify); cdecl; +begin + LazSoup2_4.soup_auth_domain_set_generic_auth_callback(@self, auth_callback, auth_data, dnotify); +end; + +function TSoupAuthDomain.try_generic_auth_callback(msg: PSoupMessage; username: Pgchar): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_auth_domain_try_generic_auth_callback(@self, msg, username); +end; + +function TSoupAuthDomainDigest.encode_password(username: Pgchar; realm: Pgchar; password: Pgchar): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_auth_domain_digest_encode_password(username, realm, password); +end; + +function TSoupSessionFeature.add_feature(type_: TGType): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_session_feature_add_feature(@self, type_); +end; + +procedure TSoupSessionFeature.attach(session: PSoupSession); cdecl; +begin + LazSoup2_4.soup_session_feature_attach(@self, session); +end; + +procedure TSoupSessionFeature.detach(session: PSoupSession); cdecl; +begin + LazSoup2_4.soup_session_feature_detach(@self, session); +end; + +function TSoupSessionFeature.has_feature(type_: TGType): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_session_feature_has_feature(@self, type_); +end; + +function TSoupSessionFeature.remove_feature(type_: TGType): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_session_feature_remove_feature(@self, type_); +end; + +procedure TSoupAuthManager.use_auth(uri: PSoupURI; auth: PSoupAuth); cdecl; +begin + LazSoup2_4.soup_auth_manager_use_auth(@self, uri, auth); +end; + +function TSoupBuffer.new(use: TSoupMemoryUse; data: Pgpointer; length: gsize): PSoupBuffer; cdecl; +begin + Result := LazSoup2_4.soup_buffer_new(use, data, length); +end; + +function TSoupBuffer.new_take(data: Pguint8; length: gsize): PSoupBuffer; cdecl; +begin + Result := LazSoup2_4.soup_buffer_new_take(data, length); +end; + +function TSoupBuffer.new_with_owner(data: Pgpointer; length: gsize; owner: gpointer; owner_dnotify: TGDestroyNotify): PSoupBuffer; cdecl; +begin + Result := LazSoup2_4.soup_buffer_new_with_owner(data, length, owner, owner_dnotify); +end; + +function TSoupBuffer.copy: PSoupBuffer; cdecl; +begin + Result := LazSoup2_4.soup_buffer_copy(@self); +end; + +procedure TSoupBuffer.free; cdecl; +begin + LazSoup2_4.soup_buffer_free(@self); +end; + +function TSoupBuffer.get_as_bytes: PGBytes; cdecl; +begin + Result := LazSoup2_4.soup_buffer_get_as_bytes(@self); +end; + +procedure TSoupBuffer.get_data(data: PPguint8; length: Pgsize); cdecl; +begin + LazSoup2_4.soup_buffer_get_data(@self, data, length); +end; + +function TSoupBuffer.get_owner: gpointer; cdecl; +begin + Result := LazSoup2_4.soup_buffer_get_owner(@self); +end; + +function TSoupBuffer.new_subbuffer(offset: gsize; length: gsize): PSoupBuffer; cdecl; +begin + Result := LazSoup2_4.soup_buffer_new_subbuffer(@self, offset, length); +end; + +function TSoupCache.new(cache_dir: Pgchar; cache_type: TSoupCacheType): PSoupCache; cdecl; +begin + Result := LazSoup2_4.soup_cache_new(cache_dir, cache_type); +end; + +procedure TSoupCache.clear; cdecl; +begin + LazSoup2_4.soup_cache_clear(@self); +end; + +procedure TSoupCache.dump; cdecl; +begin + LazSoup2_4.soup_cache_dump(@self); +end; + +procedure TSoupCache.flush; cdecl; +begin + LazSoup2_4.soup_cache_flush(@self); +end; + +function TSoupCache.get_max_size: guint; cdecl; +begin + Result := LazSoup2_4.soup_cache_get_max_size(@self); +end; + +procedure TSoupCache.load; cdecl; +begin + LazSoup2_4.soup_cache_load(@self); +end; + +procedure TSoupCache.set_max_size(max_size: guint); cdecl; +begin + LazSoup2_4.soup_cache_set_max_size(@self, max_size); +end; + +function TSoupClientContext.get_address: PSoupAddress; cdecl; +begin + Result := LazSoup2_4.soup_client_context_get_address(@self); +end; + +function TSoupClientContext.get_auth_domain: PSoupAuthDomain; cdecl; +begin + Result := LazSoup2_4.soup_client_context_get_auth_domain(@self); +end; + +function TSoupClientContext.get_auth_user: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_client_context_get_auth_user(@self); +end; + +function TSoupClientContext.get_host: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_client_context_get_host(@self); +end; + +function TSoupClientContext.get_socket: PSoupSocket; cdecl; +begin + Result := LazSoup2_4.soup_client_context_get_socket(@self); +end; + +procedure TSoupSocket.connect_async(cancellable: PGCancellable; callback: TSoupSocketCallback; user_data: gpointer); cdecl; +begin + LazSoup2_4.soup_socket_connect_async(@self, cancellable, callback, user_data); +end; + +function TSoupSocket.connect_sync(cancellable: PGCancellable): guint; cdecl; +begin + Result := LazSoup2_4.soup_socket_connect_sync(@self, cancellable); +end; + +procedure TSoupSocket.disconnect; cdecl; +begin + LazSoup2_4.soup_socket_disconnect(@self); +end; + +function TSoupSocket.get_fd: gint; cdecl; +begin + Result := LazSoup2_4.soup_socket_get_fd(@self); +end; + +function TSoupSocket.get_local_address: PSoupAddress; cdecl; +begin + Result := LazSoup2_4.soup_socket_get_local_address(@self); +end; + +function TSoupSocket.get_remote_address: PSoupAddress; cdecl; +begin + Result := LazSoup2_4.soup_socket_get_remote_address(@self); +end; + +function TSoupSocket.is_connected: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_socket_is_connected(@self); +end; + +function TSoupSocket.is_ssl: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_socket_is_ssl(@self); +end; + +function TSoupSocket.listen: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_socket_listen(@self); +end; + +function TSoupSocket.read(buffer: gpointer; len: gsize; nread: Pgsize; cancellable: PGCancellable; error: PPGError): TSoupSocketIOStatus; cdecl; +begin + Result := LazSoup2_4.soup_socket_read(@self, buffer, len, nread, cancellable, error); +end; + +function TSoupSocket.read_until(buffer: gpointer; len: gsize; boundary: Pgpointer; boundary_len: gsize; nread: Pgsize; got_boundary: Pgboolean; cancellable: PGCancellable; error: PPGError): TSoupSocketIOStatus; cdecl; +begin + Result := LazSoup2_4.soup_socket_read_until(@self, buffer, len, boundary, boundary_len, nread, got_boundary, cancellable, error); +end; + +function TSoupSocket.start_proxy_ssl(ssl_host: Pgchar; cancellable: PGCancellable): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_socket_start_proxy_ssl(@self, ssl_host, cancellable); +end; + +function TSoupSocket.start_ssl(cancellable: PGCancellable): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_socket_start_ssl(@self, cancellable); +end; + +function TSoupSocket.write(buffer: Pgpointer; len: gsize; nwrote: Pgsize; cancellable: PGCancellable; error: PPGError): TSoupSocketIOStatus; cdecl; +begin + Result := LazSoup2_4.soup_socket_write(@self, buffer, len, nwrote, cancellable, error); +end; + +function TSoupContentSniffer.new: PSoupContentSniffer; cdecl; +begin + Result := LazSoup2_4.soup_content_sniffer_new(); +end; + +function TSoupContentSniffer.get_buffer_size: gsize; cdecl; +begin + Result := LazSoup2_4.soup_content_sniffer_get_buffer_size(@self); +end; + +function TSoupContentSniffer.sniff(msg: PSoupMessage; buffer: PSoupBuffer; params: PPGHashTable): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_content_sniffer_sniff(@self, msg, buffer, params); +end; + +function TSoupDate.new(year: gint; month: gint; day: gint; hour: gint; minute: gint; second: gint): PSoupDate; cdecl; +begin + Result := LazSoup2_4.soup_date_new(year, month, day, hour, minute, second); +end; + +function TSoupDate.new_from_now(offset_seconds: gint): PSoupDate; cdecl; +begin + Result := LazSoup2_4.soup_date_new_from_now(offset_seconds); +end; + +function TSoupDate.new_from_string(date_string: Pgchar): PSoupDate; cdecl; +begin + Result := LazSoup2_4.soup_date_new_from_string(date_string); +end; + +function TSoupDate.new_from_time_t(when: glong): PSoupDate; cdecl; +begin + Result := LazSoup2_4.soup_date_new_from_time_t(when); +end; + +function TSoupDate.copy: PSoupDate; cdecl; +begin + Result := LazSoup2_4.soup_date_copy(@self); +end; + +procedure TSoupDate.free; cdecl; +begin + LazSoup2_4.soup_date_free(@self); +end; + +function TSoupDate.get_day: gint; cdecl; +begin + Result := LazSoup2_4.soup_date_get_day(@self); +end; + +function TSoupDate.get_hour: gint; cdecl; +begin + Result := LazSoup2_4.soup_date_get_hour(@self); +end; + +function TSoupDate.get_minute: gint; cdecl; +begin + Result := LazSoup2_4.soup_date_get_minute(@self); +end; + +function TSoupDate.get_month: gint; cdecl; +begin + Result := LazSoup2_4.soup_date_get_month(@self); +end; + +function TSoupDate.get_offset: gint; cdecl; +begin + Result := LazSoup2_4.soup_date_get_offset(@self); +end; + +function TSoupDate.get_second: gint; cdecl; +begin + Result := LazSoup2_4.soup_date_get_second(@self); +end; + +function TSoupDate.get_utc: gint; cdecl; +begin + Result := LazSoup2_4.soup_date_get_utc(@self); +end; + +function TSoupDate.get_year: gint; cdecl; +begin + Result := LazSoup2_4.soup_date_get_year(@self); +end; + +function TSoupDate.is_past: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_date_is_past(@self); +end; + +function TSoupDate.to_string(format: TSoupDateFormat): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_date_to_string(@self, format); +end; + +function TSoupDate.to_time_t: glong; cdecl; +begin + Result := LazSoup2_4.soup_date_to_time_t(@self); +end; + +procedure TSoupDate.to_timeval(time: PGTimeVal); cdecl; +begin + LazSoup2_4.soup_date_to_timeval(@self, time); +end; + +function TSoupCookie.new(name: Pgchar; value: Pgchar; domain: Pgchar; path: Pgchar; max_age: gint): PSoupCookie; cdecl; +begin + Result := LazSoup2_4.soup_cookie_new(name, value, domain, path, max_age); +end; + +function TSoupCookie.applies_to_uri(uri: PSoupURI): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_cookie_applies_to_uri(@self, uri); +end; + +function TSoupCookie.copy: PSoupCookie; cdecl; +begin + Result := LazSoup2_4.soup_cookie_copy(@self); +end; + +function TSoupCookie.domain_matches(host: Pgchar): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_cookie_domain_matches(@self, host); +end; + +function TSoupCookie.equal(cookie2: PSoupCookie): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_cookie_equal(@self, cookie2); +end; + +procedure TSoupCookie.free; cdecl; +begin + LazSoup2_4.soup_cookie_free(@self); +end; + +function TSoupCookie.get_domain: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_cookie_get_domain(@self); +end; + +function TSoupCookie.get_expires: PSoupDate; cdecl; +begin + Result := LazSoup2_4.soup_cookie_get_expires(@self); +end; + +function TSoupCookie.get_http_only: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_cookie_get_http_only(@self); +end; + +function TSoupCookie.get_name: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_cookie_get_name(@self); +end; + +function TSoupCookie.get_path: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_cookie_get_path(@self); +end; + +function TSoupCookie.get_secure: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_cookie_get_secure(@self); +end; + +function TSoupCookie.get_value: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_cookie_get_value(@self); +end; + +procedure TSoupCookie.set_domain(domain: Pgchar); cdecl; +begin + LazSoup2_4.soup_cookie_set_domain(@self, domain); +end; + +procedure TSoupCookie.set_expires(expires: PSoupDate); cdecl; +begin + LazSoup2_4.soup_cookie_set_expires(@self, expires); +end; + +procedure TSoupCookie.set_http_only(http_only: gboolean); cdecl; +begin + LazSoup2_4.soup_cookie_set_http_only(@self, http_only); +end; + +procedure TSoupCookie.set_max_age(max_age: gint); cdecl; +begin + LazSoup2_4.soup_cookie_set_max_age(@self, max_age); +end; + +procedure TSoupCookie.set_name(name: Pgchar); cdecl; +begin + LazSoup2_4.soup_cookie_set_name(@self, name); +end; + +procedure TSoupCookie.set_path(path: Pgchar); cdecl; +begin + LazSoup2_4.soup_cookie_set_path(@self, path); +end; + +procedure TSoupCookie.set_secure(secure: gboolean); cdecl; +begin + LazSoup2_4.soup_cookie_set_secure(@self, secure); +end; + +procedure TSoupCookie.set_value(value: Pgchar); cdecl; +begin + LazSoup2_4.soup_cookie_set_value(@self, value); +end; + +function TSoupCookie.to_cookie_header: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_cookie_to_cookie_header(@self); +end; + +function TSoupCookie.to_set_cookie_header: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_cookie_to_set_cookie_header(@self); +end; + +function TSoupCookie.parse(header: Pgchar; origin: PSoupURI): PSoupCookie; cdecl; +begin + Result := LazSoup2_4.soup_cookie_parse(header, origin); +end; + +function TSoupCookieJar.new: PSoupCookieJar; cdecl; +begin + Result := LazSoup2_4.soup_cookie_jar_new(); +end; + +procedure TSoupCookieJar.add_cookie(cookie: PSoupCookie); cdecl; +begin + LazSoup2_4.soup_cookie_jar_add_cookie(@self, cookie); +end; + +procedure TSoupCookieJar.add_cookie_with_first_party(first_party: PSoupURI; cookie: PSoupCookie); cdecl; +begin + LazSoup2_4.soup_cookie_jar_add_cookie_with_first_party(@self, first_party, cookie); +end; + +function TSoupCookieJar.all_cookies: PGSList; cdecl; +begin + Result := LazSoup2_4.soup_cookie_jar_all_cookies(@self); +end; + +procedure TSoupCookieJar.delete_cookie(cookie: PSoupCookie); cdecl; +begin + LazSoup2_4.soup_cookie_jar_delete_cookie(@self, cookie); +end; + +function TSoupCookieJar.get_accept_policy: TSoupCookieJarAcceptPolicy; cdecl; +begin + Result := LazSoup2_4.soup_cookie_jar_get_accept_policy(@self); +end; + +function TSoupCookieJar.get_cookie_list(uri: PSoupURI; for_http: gboolean): PGSList; cdecl; +begin + Result := LazSoup2_4.soup_cookie_jar_get_cookie_list(@self, uri, for_http); +end; + +function TSoupCookieJar.get_cookies(uri: PSoupURI; for_http: gboolean): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_cookie_jar_get_cookies(@self, uri, for_http); +end; + +function TSoupCookieJar.is_persistent: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_cookie_jar_is_persistent(@self); +end; + +procedure TSoupCookieJar.set_accept_policy(policy: TSoupCookieJarAcceptPolicy); cdecl; +begin + LazSoup2_4.soup_cookie_jar_set_accept_policy(@self, policy); +end; + +procedure TSoupCookieJar.set_cookie(uri: PSoupURI; cookie: Pgchar); cdecl; +begin + LazSoup2_4.soup_cookie_jar_set_cookie(@self, uri, cookie); +end; + +procedure TSoupCookieJar.set_cookie_with_first_party(uri: PSoupURI; first_party: PSoupURI; cookie: Pgchar); cdecl; +begin + LazSoup2_4.soup_cookie_jar_set_cookie_with_first_party(@self, uri, first_party, cookie); +end; + +function TSoupCookieJarDB.new(filename: Pgchar; read_only: gboolean): PSoupCookieJarDB; cdecl; +begin + Result := LazSoup2_4.soup_cookie_jar_db_new(filename, read_only); +end; + +function TSoupCookieJarText.new(filename: Pgchar; read_only: gboolean): PSoupCookieJarText; cdecl; +begin + Result := LazSoup2_4.soup_cookie_jar_text_new(filename, read_only); +end; + +function TSoupLogger.new(level: TSoupLoggerLogLevel; max_body_size: gint): PSoupLogger; cdecl; +begin + Result := LazSoup2_4.soup_logger_new(level, max_body_size); +end; + +procedure TSoupLogger.set_printer(printer: TSoupLoggerPrinter; printer_data: gpointer; destroy_: TGDestroyNotify); cdecl; +begin + LazSoup2_4.soup_logger_set_printer(@self, printer, printer_data, destroy_); +end; + +procedure TSoupLogger.set_request_filter(request_filter: TSoupLoggerFilter; filter_data: gpointer; destroy_: TGDestroyNotify); cdecl; +begin + LazSoup2_4.soup_logger_set_request_filter(@self, request_filter, filter_data, destroy_); +end; + +procedure TSoupLogger.set_response_filter(response_filter: TSoupLoggerFilter; filter_data: gpointer; destroy_: TGDestroyNotify); cdecl; +begin + LazSoup2_4.soup_logger_set_response_filter(@self, response_filter, filter_data, destroy_); +end; + +function TSoupSession.new: PSoupSession; cdecl; +begin + Result := LazSoup2_4.soup_session_new(); +end; + +procedure TSoupSession.abort; cdecl; +begin + LazSoup2_4.soup_session_abort(@self); +end; + +procedure TSoupSession.add_feature(feature: PSoupSessionFeature); cdecl; +begin + LazSoup2_4.soup_session_add_feature(@self, feature); +end; + +procedure TSoupSession.add_feature_by_type(feature_type: TGType); cdecl; +begin + LazSoup2_4.soup_session_add_feature_by_type(@self, feature_type); +end; + +procedure TSoupSession.cancel_message(msg: PSoupMessage; status_code: guint); cdecl; +begin + LazSoup2_4.soup_session_cancel_message(@self, msg, status_code); +end; + +function TSoupSession.get_async_context: PGMainContext; cdecl; +begin + Result := LazSoup2_4.soup_session_get_async_context(@self); +end; + +function TSoupSession.get_feature(feature_type: TGType): PSoupSessionFeature; cdecl; +begin + Result := LazSoup2_4.soup_session_get_feature(@self, feature_type); +end; + +function TSoupSession.get_feature_for_message(feature_type: TGType; msg: PSoupMessage): PSoupSessionFeature; cdecl; +begin + Result := LazSoup2_4.soup_session_get_feature_for_message(@self, feature_type, msg); +end; + +function TSoupSession.get_features(feature_type: TGType): PGSList; cdecl; +begin + Result := LazSoup2_4.soup_session_get_features(@self, feature_type); +end; + +function TSoupSession.has_feature(feature_type: TGType): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_session_has_feature(@self, feature_type); +end; + +procedure TSoupSession.pause_message(msg: PSoupMessage); cdecl; +begin + LazSoup2_4.soup_session_pause_message(@self, msg); +end; + +procedure TSoupSession.prefetch_dns(hostname: Pgchar; cancellable: PGCancellable; callback: TSoupAddressCallback; user_data: gpointer); cdecl; +begin + LazSoup2_4.soup_session_prefetch_dns(@self, hostname, cancellable, callback, user_data); +end; + +procedure TSoupSession.queue_message(msg: PSoupMessage; callback: TSoupSessionCallback; user_data: gpointer); cdecl; +begin + LazSoup2_4.soup_session_queue_message(@self, msg, callback, user_data); +end; + +function TSoupSession.redirect_message(msg: PSoupMessage): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_session_redirect_message(@self, msg); +end; + +procedure TSoupSession.remove_feature(feature: PSoupSessionFeature); cdecl; +begin + LazSoup2_4.soup_session_remove_feature(@self, feature); +end; + +procedure TSoupSession.remove_feature_by_type(feature_type: TGType); cdecl; +begin + LazSoup2_4.soup_session_remove_feature_by_type(@self, feature_type); +end; + +function TSoupSession.request(uri_string: Pgchar; error: PPGError): PSoupRequest; cdecl; +begin + Result := LazSoup2_4.soup_session_request(@self, uri_string, error); +end; + +function TSoupSession.request_http(method: Pgchar; uri_string: Pgchar; error: PPGError): PSoupRequestHTTP; cdecl; +begin + Result := LazSoup2_4.soup_session_request_http(@self, method, uri_string, error); +end; + +function TSoupSession.request_http_uri(method: Pgchar; uri: PSoupURI; error: PPGError): PSoupRequestHTTP; cdecl; +begin + Result := LazSoup2_4.soup_session_request_http_uri(@self, method, uri, error); +end; + +function TSoupSession.request_uri(uri: PSoupURI; error: PPGError): PSoupRequest; cdecl; +begin + Result := LazSoup2_4.soup_session_request_uri(@self, uri, error); +end; + +procedure TSoupSession.requeue_message(msg: PSoupMessage); cdecl; +begin + LazSoup2_4.soup_session_requeue_message(@self, msg); +end; + +function TSoupSession.send(msg: PSoupMessage; cancellable: PGCancellable; error: PPGError): PGInputStream; cdecl; +begin + Result := LazSoup2_4.soup_session_send(@self, msg, cancellable, error); +end; + +procedure TSoupSession.send_async(msg: PSoupMessage; cancellable: PGCancellable; callback: TGAsyncReadyCallback; user_data: gpointer); cdecl; +begin + LazSoup2_4.soup_session_send_async(@self, msg, cancellable, callback, user_data); +end; + +function TSoupSession.send_finish(result_: PGAsyncResult; error: PPGError): PGInputStream; cdecl; +begin + Result := LazSoup2_4.soup_session_send_finish(@self, result_, error); +end; + +function TSoupSession.send_message(msg: PSoupMessage): guint; cdecl; +begin + Result := LazSoup2_4.soup_session_send_message(@self, msg); +end; + +procedure TSoupSession.unpause_message(msg: PSoupMessage); cdecl; +begin + LazSoup2_4.soup_session_unpause_message(@self, msg); +end; + +function TSoupSession.would_redirect(msg: PSoupMessage): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_session_would_redirect(@self, msg); +end; + +function TSoupRequest.get_content_length: gint64; cdecl; +begin + Result := LazSoup2_4.soup_request_get_content_length(@self); +end; + +function TSoupRequest.get_content_type: Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_request_get_content_type(@self); +end; + +function TSoupRequest.get_session: PSoupSession; cdecl; +begin + Result := LazSoup2_4.soup_request_get_session(@self); +end; + +function TSoupRequest.get_uri: PSoupURI; cdecl; +begin + Result := LazSoup2_4.soup_request_get_uri(@self); +end; + +function TSoupRequest.send(cancellable: PGCancellable; error: PPGError): PGInputStream; cdecl; +begin + Result := LazSoup2_4.soup_request_send(@self, cancellable, error); +end; + +procedure TSoupRequest.send_async(cancellable: PGCancellable; callback: TGAsyncReadyCallback; user_data: gpointer); cdecl; +begin + LazSoup2_4.soup_request_send_async(@self, cancellable, callback, user_data); +end; + +function TSoupRequest.send_finish(result_: PGAsyncResult; error: PPGError): PGInputStream; cdecl; +begin + Result := LazSoup2_4.soup_request_send_finish(@self, result_, error); +end; + +function TSoupMessageBody.new: PSoupMessageBody; cdecl; +begin + Result := LazSoup2_4.soup_message_body_new(); +end; + +procedure TSoupMessageBody.append(use: TSoupMemoryUse; data: guint8; length: gsize); cdecl; +begin + LazSoup2_4.soup_message_body_append(@self, use, data, length); +end; + +procedure TSoupMessageBody.append_buffer(buffer: PSoupBuffer); cdecl; +begin + LazSoup2_4.soup_message_body_append_buffer(@self, buffer); +end; + +procedure TSoupMessageBody.append_take(data: Pguint8; length: gsize); cdecl; +begin + LazSoup2_4.soup_message_body_append_take(@self, data, length); +end; + +procedure TSoupMessageBody.complete; cdecl; +begin + LazSoup2_4.soup_message_body_complete(@self); +end; + +function TSoupMessageBody.flatten: PSoupBuffer; cdecl; +begin + Result := LazSoup2_4.soup_message_body_flatten(@self); +end; + +procedure TSoupMessageBody.free; cdecl; +begin + LazSoup2_4.soup_message_body_free(@self); +end; + +function TSoupMessageBody.get_accumulate: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_message_body_get_accumulate(@self); +end; + +function TSoupMessageBody.get_chunk(offset: gint64): PSoupBuffer; cdecl; +begin + Result := LazSoup2_4.soup_message_body_get_chunk(@self, offset); +end; + +procedure TSoupMessageBody.got_chunk(chunk: PSoupBuffer); cdecl; +begin + LazSoup2_4.soup_message_body_got_chunk(@self, chunk); +end; + +procedure TSoupMessageBody.set_accumulate(accumulate: gboolean); cdecl; +begin + LazSoup2_4.soup_message_body_set_accumulate(@self, accumulate); +end; + +procedure TSoupMessageBody.truncate; cdecl; +begin + LazSoup2_4.soup_message_body_truncate(@self); +end; + +procedure TSoupMessageBody.wrote_chunk(chunk: PSoupBuffer); cdecl; +begin + LazSoup2_4.soup_message_body_wrote_chunk(@self, chunk); +end; + +function TSoupMessageHeaders.new(type_: TSoupMessageHeadersType): PSoupMessageHeaders; cdecl; +begin + Result := LazSoup2_4.soup_message_headers_new(type_); +end; + +procedure TSoupMessageHeaders.append(name: Pgchar; value: Pgchar); cdecl; +begin + LazSoup2_4.soup_message_headers_append(@self, name, value); +end; + +procedure TSoupMessageHeaders.clean_connection_headers; cdecl; +begin + LazSoup2_4.soup_message_headers_clean_connection_headers(@self); +end; + +procedure TSoupMessageHeaders.clear; cdecl; +begin + LazSoup2_4.soup_message_headers_clear(@self); +end; + +procedure TSoupMessageHeaders.foreach(func: TSoupMessageHeadersForeachFunc; user_data: gpointer); cdecl; +begin + LazSoup2_4.soup_message_headers_foreach(@self, func, user_data); +end; + +procedure TSoupMessageHeaders.free; cdecl; +begin + LazSoup2_4.soup_message_headers_free(@self); +end; + +procedure TSoupMessageHeaders.free_ranges(ranges: PSoupRange); cdecl; +begin + LazSoup2_4.soup_message_headers_free_ranges(@self, ranges); +end; + +function TSoupMessageHeaders.get_content_disposition(disposition: PPgchar; params: PPGHashTable): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_message_headers_get_content_disposition(@self, disposition, params); +end; + +function TSoupMessageHeaders.get_content_length: gint64; cdecl; +begin + Result := LazSoup2_4.soup_message_headers_get_content_length(@self); +end; + +function TSoupMessageHeaders.get_content_range(start: Pgint64; end_: Pgint64; total_length: Pgint64): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_message_headers_get_content_range(@self, start, end_, total_length); +end; + +function TSoupMessageHeaders.get_content_type(params: PPGHashTable): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_message_headers_get_content_type(@self, params); +end; + +function TSoupMessageHeaders.get_encoding: TSoupEncoding; cdecl; +begin + Result := LazSoup2_4.soup_message_headers_get_encoding(@self); +end; + +function TSoupMessageHeaders.get_expectations: TSoupExpectation; cdecl; +begin + Result := LazSoup2_4.soup_message_headers_get_expectations(@self); +end; + +function TSoupMessageHeaders.get_list(name: Pgchar): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_message_headers_get_list(@self, name); +end; + +function TSoupMessageHeaders.get_one(name: Pgchar): Pgchar; cdecl; +begin + Result := LazSoup2_4.soup_message_headers_get_one(@self, name); +end; + +function TSoupMessageHeaders.get_ranges(total_length: gint64; ranges: PPSoupRange; length: Pgint): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_message_headers_get_ranges(@self, total_length, ranges, length); +end; + +procedure TSoupMessageHeaders.remove(name: Pgchar); cdecl; +begin + LazSoup2_4.soup_message_headers_remove(@self, name); +end; + +procedure TSoupMessageHeaders.replace(name: Pgchar; value: Pgchar); cdecl; +begin + LazSoup2_4.soup_message_headers_replace(@self, name, value); +end; + +procedure TSoupMessageHeaders.set_content_disposition(disposition: Pgchar; params: PGHashTable); cdecl; +begin + LazSoup2_4.soup_message_headers_set_content_disposition(@self, disposition, params); +end; + +procedure TSoupMessageHeaders.set_content_length(content_length: gint64); cdecl; +begin + LazSoup2_4.soup_message_headers_set_content_length(@self, content_length); +end; + +procedure TSoupMessageHeaders.set_content_range(start: gint64; end_: gint64; total_length: gint64); cdecl; +begin + LazSoup2_4.soup_message_headers_set_content_range(@self, start, end_, total_length); +end; + +procedure TSoupMessageHeaders.set_content_type(content_type: Pgchar; params: PGHashTable); cdecl; +begin + LazSoup2_4.soup_message_headers_set_content_type(@self, content_type, params); +end; + +procedure TSoupMessageHeaders.set_encoding(encoding: TSoupEncoding); cdecl; +begin + LazSoup2_4.soup_message_headers_set_encoding(@self, encoding); +end; + +procedure TSoupMessageHeaders.set_expectations(expectations: TSoupExpectation); cdecl; +begin + LazSoup2_4.soup_message_headers_set_expectations(@self, expectations); +end; + +procedure TSoupMessageHeaders.set_range(start: gint64; end_: gint64); cdecl; +begin + LazSoup2_4.soup_message_headers_set_range(@self, start, end_); +end; + +procedure TSoupMessageHeaders.set_ranges(ranges: PSoupRange; length: gint); cdecl; +begin + LazSoup2_4.soup_message_headers_set_ranges(@self, ranges, length); +end; + +function TSoupMessageHeadersIter.next(name: PPgchar; value: PPgchar): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_message_headers_iter_next(@self, name, value); +end; + +procedure TSoupMessageHeadersIter.init(iter: PSoupMessageHeadersIter; hdrs: PSoupMessageHeaders); cdecl; +begin + LazSoup2_4.soup_message_headers_iter_init(iter, hdrs); +end; + +function TSoupMultipart.new(mime_type: Pgchar): PSoupMultipart; cdecl; +begin + Result := LazSoup2_4.soup_multipart_new(mime_type); +end; + +function TSoupMultipart.new_from_message(headers: PSoupMessageHeaders; body: PSoupMessageBody): PSoupMultipart; cdecl; +begin + Result := LazSoup2_4.soup_multipart_new_from_message(headers, body); +end; + +procedure TSoupMultipart.append_form_file(control_name: Pgchar; filename: Pgchar; content_type: Pgchar; body: PSoupBuffer); cdecl; +begin + LazSoup2_4.soup_multipart_append_form_file(@self, control_name, filename, content_type, body); +end; + +procedure TSoupMultipart.append_form_string(control_name: Pgchar; data: Pgchar); cdecl; +begin + LazSoup2_4.soup_multipart_append_form_string(@self, control_name, data); +end; + +procedure TSoupMultipart.append_part(headers: PSoupMessageHeaders; body: PSoupBuffer); cdecl; +begin + LazSoup2_4.soup_multipart_append_part(@self, headers, body); +end; + +procedure TSoupMultipart.free; cdecl; +begin + LazSoup2_4.soup_multipart_free(@self); +end; + +function TSoupMultipart.get_length: gint; cdecl; +begin + Result := LazSoup2_4.soup_multipart_get_length(@self); +end; + +function TSoupMultipart.get_part(part: gint; headers: PPSoupMessageHeaders; body: PPSoupBuffer): gboolean; cdecl; +begin + Result := LazSoup2_4.soup_multipart_get_part(@self, part, headers, body); +end; + +procedure TSoupMultipart.to_message(dest_headers: PSoupMessageHeaders; dest_body: PSoupMessageBody); cdecl; +begin + LazSoup2_4.soup_multipart_to_message(@self, dest_headers, dest_body); +end; + +function TSoupMultipartInputStream.new(msg: PSoupMessage; base_stream: PGInputStream): PSoupMultipartInputStream; cdecl; +begin + Result := LazSoup2_4.soup_multipart_input_stream_new(msg, base_stream); +end; + +function TSoupMultipartInputStream.get_headers: PSoupMessageHeaders; cdecl; +begin + Result := LazSoup2_4.soup_multipart_input_stream_get_headers(@self); +end; + +function TSoupMultipartInputStream.next_part(cancellable: PGCancellable; error: PPGError): PGInputStream; cdecl; +begin + Result := LazSoup2_4.soup_multipart_input_stream_next_part(@self, cancellable, error); +end; + +procedure TSoupMultipartInputStream.next_part_async(io_priority: gint; cancellable: PGCancellable; callback: TGAsyncReadyCallback; data: gpointer); cdecl; +begin + LazSoup2_4.soup_multipart_input_stream_next_part_async(@self, io_priority, cancellable, callback, data); +end; + +function TSoupMultipartInputStream.next_part_finish(result_: PGAsyncResult; error: PPGError): PGInputStream; cdecl; +begin + Result := LazSoup2_4.soup_multipart_input_stream_next_part_finish(@self, result_, error); +end; + +procedure TSoupPasswordManager.get_passwords_async(msg: PSoupMessage; auth: PSoupAuth; retrying: gboolean; async_context: PGMainContext; cancellable: PGCancellable; callback: TSoupPasswordManagerCallback; user_data: gpointer); cdecl; +begin + LazSoup2_4.soup_password_manager_get_passwords_async(@self, msg, auth, retrying, async_context, cancellable, callback, user_data); +end; + +procedure TSoupPasswordManager.get_passwords_sync(msg: PSoupMessage; auth: PSoupAuth; cancellable: PGCancellable); cdecl; +begin + LazSoup2_4.soup_password_manager_get_passwords_sync(@self, msg, auth, cancellable); +end; + +procedure TSoupProxyURIResolver.get_proxy_uri_async(uri: PSoupURI; async_context: PGMainContext; cancellable: PGCancellable; callback: TSoupProxyURIResolverCallback; user_data: gpointer); cdecl; +begin + LazSoup2_4.soup_proxy_uri_resolver_get_proxy_uri_async(@self, uri, async_context, cancellable, callback, user_data); +end; + +function TSoupProxyURIResolver.get_proxy_uri_sync(uri: PSoupURI; cancellable: PGCancellable; proxy_uri: PPSoupURI): guint; cdecl; +begin + Result := LazSoup2_4.soup_proxy_uri_resolver_get_proxy_uri_sync(@self, uri, cancellable, proxy_uri); +end; + +function TSoupRequestFile.get_file: PGFile; cdecl; +begin + Result := LazSoup2_4.soup_request_file_get_file(@self); +end; + +function TSoupRequestHTTP.get_message: PSoupMessage; cdecl; +begin + Result := LazSoup2_4.soup_request_http_get_message(@self); +end; + +function TSoupRequester.new: PSoupRequester; cdecl; +begin + Result := LazSoup2_4.soup_requester_new(); +end; + +function TSoupRequester.request(uri_string: Pgchar; error: PPGError): PSoupRequest; cdecl; +begin + Result := LazSoup2_4.soup_requester_request(@self, uri_string, error); +end; + +function TSoupRequester.request_uri(uri: PSoupURI; error: PPGError): PSoupRequest; cdecl; +begin + Result := LazSoup2_4.soup_requester_request_uri(@self, uri, error); +end; + +procedure TSoupServer.add_auth_domain(auth_domain: PSoupAuthDomain); cdecl; +begin + LazSoup2_4.soup_server_add_auth_domain(@self, auth_domain); +end; + +procedure TSoupServer.add_handler(path: Pgchar; callback: TSoupServerCallback; user_data: gpointer; destroy_: TGDestroyNotify); cdecl; +begin + LazSoup2_4.soup_server_add_handler(@self, path, callback, user_data, destroy_); +end; + +procedure TSoupServer.disconnect; cdecl; +begin + LazSoup2_4.soup_server_disconnect(@self); +end; + +function TSoupServer.get_async_context: PGMainContext; cdecl; +begin + Result := LazSoup2_4.soup_server_get_async_context(@self); +end; + +function TSoupServer.get_listener: PSoupSocket; cdecl; +begin + Result := LazSoup2_4.soup_server_get_listener(@self); +end; + +function TSoupServer.get_port: guint; cdecl; +begin + Result := LazSoup2_4.soup_server_get_port(@self); +end; + +function TSoupServer.is_https: gboolean; cdecl; +begin + Result := LazSoup2_4.soup_server_is_https(@self); +end; + +procedure TSoupServer.pause_message(msg: PSoupMessage); cdecl; +begin + LazSoup2_4.soup_server_pause_message(@self, msg); +end; + +procedure TSoupServer.quit; cdecl; +begin + LazSoup2_4.soup_server_quit(@self); +end; + +procedure TSoupServer.remove_auth_domain(auth_domain: PSoupAuthDomain); cdecl; +begin + LazSoup2_4.soup_server_remove_auth_domain(@self, auth_domain); +end; + +procedure TSoupServer.remove_handler(path: Pgchar); cdecl; +begin + LazSoup2_4.soup_server_remove_handler(@self, path); +end; + +procedure TSoupServer.run; cdecl; +begin + LazSoup2_4.soup_server_run(@self); +end; + +procedure TSoupServer.run_async; cdecl; +begin + LazSoup2_4.soup_server_run_async(@self); +end; + +procedure TSoupServer.unpause_message(msg: PSoupMessage); cdecl; +begin + LazSoup2_4.soup_server_unpause_message(@self, msg); +end; + +end.
\ No newline at end of file |