/// <reference path="./gio-2.0.d.ts" />
/// <reference path="./gobject-2.0.d.ts" />
/// <reference path="./glib-2.0.d.ts" />
/// <reference path="./gmodule-2.0.d.ts" />

/**
 * Type Definitions for Gjs (https://gjs.guide/)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
 *
 * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
 */

declare module 'gi://Soup?version=2.4' {
    // Module dependencies
    import type Gio from 'gi://Gio?version=2.0';
    import type GObject from 'gi://GObject?version=2.0';
    import type GLib from 'gi://GLib?version=2.0';
    import type GModule from 'gi://GModule?version=2.0';

    export namespace Soup {
        /**
         * Soup-2.4
         */

        /**
         * The supported address families.
         */

        /**
         * The supported address families.
         */
        export namespace AddressFamily {
            export const $gtype: GObject.GType<AddressFamily>;
        }

        enum AddressFamily {
            /**
             * an invalid %SoupAddress
             */
            INVALID,
            /**
             * an IPv4 address
             */
            IPV4,
            /**
             * an IPv6 address
             */
            IPV6,
        }

        export namespace CacheResponse {
            export const $gtype: GObject.GType<CacheResponse>;
        }

        enum CacheResponse {
            FRESH,
            NEEDS_VALIDATION,
            STALE,
        }
        /**
         * The type of cache; this affects what kinds of responses will be
         * saved.
         */

        /**
         * The type of cache; this affects what kinds of responses will be
         * saved.
         */
        export namespace CacheType {
            export const $gtype: GObject.GType<CacheType>;
        }

        enum CacheType {
            /**
             * a single-user cache
             */
            SINGLE_USER,
            /**
             * a shared cache
             */
            SHARED,
        }

        export namespace ConnectionState {
            export const $gtype: GObject.GType<ConnectionState>;
        }

        enum ConnectionState {
            NEW,
            CONNECTING,
            IDLE,
            IN_USE,
            REMOTE_DISCONNECTED,
            DISCONNECTED,
        }
        /**
         * The policy for accepting or rejecting cookies returned in
         * responses.
         */

        /**
         * The policy for accepting or rejecting cookies returned in
         * responses.
         */
        export namespace CookieJarAcceptPolicy {
            export const $gtype: GObject.GType<CookieJarAcceptPolicy>;
        }

        enum CookieJarAcceptPolicy {
            /**
             * accept all cookies unconditionally.
             */
            ALWAYS,
            /**
             * reject all cookies unconditionally.
             */
            NEVER,
            /**
             * accept all cookies set by
             * the main document loaded in the application using libsoup. An
             * example of the most common case, web browsers, would be: If
             * http://www.example.com is the page loaded, accept all cookies set
             * by example.com, but if a resource from http://www.third-party.com
             * is loaded from that page reject any cookie that it could try to
             * set. For libsoup to be able to tell apart first party cookies from
             * the rest, the application must call soup_message_set_first_party()
             * on each outgoing #SoupMessage, setting the #SoupURI of the main
             * document. If no first party is set in a message when this policy is
             * in effect, cookies will be assumed to be third party by default.
             */
            NO_THIRD_PARTY,
            /**
             * accept all cookies
             * set by the main document loaded in the application using libsoup, and
             * from domains that have previously set at least one cookie when loaded
             * as the main document. An example of the most common case, web browsers,
             * would be: if http://www.example.com is the page loaded, accept all
             * cookies set by example.com, but if a resource from http://www.third-party.com
             * is loaded from that page, reject any cookie that it could try to
             * set unless it already has a cookie in the cookie jar. For libsoup to
             * be able to tell apart first party cookies from the rest, the
             * application must call soup_message_set_first_party() on each outgoing
             * #SoupMessage, setting the #SoupURI of the main document. If no first
             * party is set in a message when this policy is in effect, cookies will
             * be assumed to be third party by default. Since 2.72.
             */
            GRANDFATHERED_THIRD_PARTY,
        }
        /**
         * Date formats that soup_date_to_string() can use.
         *
         * `SOUP_DATE_HTTP` and `SOUP_DATE_COOKIE` always coerce the time to
         * UTC. `SOUP_DATE_ISO8`601_XMLRPC uses the time as given, ignoring the
         * offset completely. `SOUP_DATE_RFC2`822 and the other ISO 8601
         * variants use the local time, appending the offset information if
         * available.
         *
         * This enum may be extended with more values in future releases.
         */

        /**
         * Date formats that soup_date_to_string() can use.
         *
         * `SOUP_DATE_HTTP` and `SOUP_DATE_COOKIE` always coerce the time to
         * UTC. `SOUP_DATE_ISO8`601_XMLRPC uses the time as given, ignoring the
         * offset completely. `SOUP_DATE_RFC2`822 and the other ISO 8601
         * variants use the local time, appending the offset information if
         * available.
         *
         * This enum may be extended with more values in future releases.
         */
        export namespace DateFormat {
            export const $gtype: GObject.GType<DateFormat>;
        }

        enum DateFormat {
            /**
             * RFC 1123 format, used by the HTTP "Date" header. Eg
             * "Sun, 06 Nov 1994 08:49:37 GMT"
             */
            HTTP,
            /**
             * The format for the "Expires" timestamp in the
             * Netscape cookie specification. Eg, "Sun, 06-Nov-1994 08:49:37 GMT".
             */
            COOKIE,
            /**
             * RFC 2822 format, eg "Sun, 6 Nov 1994 09:49:37 -0100"
             */
            RFC2822,
            /**
             * ISO 8601 date/time with no optional
             * punctuation. Eg, "19941106T094937-0100".
             */
            ISO8601_COMPACT,
            /**
             * ISO 8601 date/time with all optional
             * punctuation. Eg, "1994-11-06T09:49:37-01:00".
             */
            ISO8601_FULL,
            /**
             * An alias for `SOUP_DATE_ISO8`601_FULL.
             */
            ISO8601,
            /**
             * ISO 8601 date/time as used by XML-RPC.
             * Eg, "19941106T09:49:37".
             */
            ISO8601_XMLRPC,
        }
        /**
         * How a message body is encoded for transport
         */

        /**
         * How a message body is encoded for transport
         */
        export namespace Encoding {
            export const $gtype: GObject.GType<Encoding>;
        }

        enum Encoding {
            /**
             * unknown / error
             */
            UNRECOGNIZED,
            /**
             * no body is present (which is not the same as a
             * 0-length body, and only occurs in certain places)
             */
            NONE,
            /**
             * Content-Length encoding
             */
            CONTENT_LENGTH,
            /**
             * Response body ends when the connection is closed
             */
            EOF,
            /**
             * chunked encoding (currently only supported
             * for response)
             */
            CHUNKED,
            /**
             * multipart/byteranges (Reserved for future
             * use: NOT CURRENTLY IMPLEMENTED)
             */
            BYTERANGES,
        }
        /**
         * Indicates the HTTP protocol version being used.
         */

        /**
         * Indicates the HTTP protocol version being used.
         */
        export namespace HTTPVersion {
            export const $gtype: GObject.GType<HTTPVersion>;
        }

        enum HTTPVersion {
            /**
             * HTTP 1.0 (RFC 1945)
             */
            HTTP_1_0,
            /**
             * HTTP 1.1 (RFC 2616)
             */
            HTTP_1_1,
        }

        export namespace KnownStatusCode {
            export const $gtype: GObject.GType<KnownStatusCode>;
        }

        enum KnownStatusCode {
            NONE,
            CANCELLED,
            CANT_RESOLVE,
            CANT_RESOLVE_PROXY,
            CANT_CONNECT,
            CANT_CONNECT_PROXY,
            SSL_FAILED,
            IO_ERROR,
            MALFORMED,
            TRY_AGAIN,
            TOO_MANY_REDIRECTS,
            TLS_FAILED,
            CONTINUE,
            SWITCHING_PROTOCOLS,
            PROCESSING,
            OK,
            CREATED,
            ACCEPTED,
            NON_AUTHORITATIVE,
            NO_CONTENT,
            RESET_CONTENT,
            PARTIAL_CONTENT,
            MULTI_STATUS,
            MULTIPLE_CHOICES,
            MOVED_PERMANENTLY,
            FOUND,
            MOVED_TEMPORARILY,
            SEE_OTHER,
            NOT_MODIFIED,
            USE_PROXY,
            NOT_APPEARING_IN_THIS_PROTOCOL,
            TEMPORARY_REDIRECT,
            BAD_REQUEST,
            UNAUTHORIZED,
            PAYMENT_REQUIRED,
            FORBIDDEN,
            NOT_FOUND,
            METHOD_NOT_ALLOWED,
            NOT_ACCEPTABLE,
            PROXY_AUTHENTICATION_REQUIRED,
            PROXY_UNAUTHORIZED,
            REQUEST_TIMEOUT,
            CONFLICT,
            GONE,
            LENGTH_REQUIRED,
            PRECONDITION_FAILED,
            REQUEST_ENTITY_TOO_LARGE,
            REQUEST_URI_TOO_LONG,
            UNSUPPORTED_MEDIA_TYPE,
            REQUESTED_RANGE_NOT_SATISFIABLE,
            INVALID_RANGE,
            EXPECTATION_FAILED,
            UNPROCESSABLE_ENTITY,
            LOCKED,
            FAILED_DEPENDENCY,
            INTERNAL_SERVER_ERROR,
            NOT_IMPLEMENTED,
            BAD_GATEWAY,
            SERVICE_UNAVAILABLE,
            GATEWAY_TIMEOUT,
            HTTP_VERSION_NOT_SUPPORTED,
            INSUFFICIENT_STORAGE,
            NOT_EXTENDED,
        }
        /**
         * Describes the level of logging output to provide.
         */

        /**
         * Describes the level of logging output to provide.
         */
        export namespace LoggerLogLevel {
            export const $gtype: GObject.GType<LoggerLogLevel>;
        }

        enum LoggerLogLevel {
            /**
             * No logging
             */
            NONE,
            /**
             * Log the Request-Line or Status-Line and
             * the Soup-Debug pseudo-headers
             */
            MINIMAL,
            /**
             * Log the full request/response headers
             */
            HEADERS,
            /**
             * Log the full headers and request/response
             * bodies.
             */
            BODY,
        }
        /**
         * Describes how #SoupBuffer should use the data passed in by the
         * caller.
         *
         * See also soup_buffer_new_with_owner(), which allows to you create a
         * buffer containing data which is owned by another object.
         */

        /**
         * Describes how #SoupBuffer should use the data passed in by the
         * caller.
         *
         * See also soup_buffer_new_with_owner(), which allows to you create a
         * buffer containing data which is owned by another object.
         */
        export namespace MemoryUse {
            export const $gtype: GObject.GType<MemoryUse>;
        }

        enum MemoryUse {
            /**
             * The memory is statically allocated and
             * constant; libsoup can use the passed-in buffer directly and not
             * need to worry about it being modified or freed.
             */
            STATIC,
            /**
             * The caller has allocated the memory for the
             * #SoupBuffer's use; libsoup will assume ownership of it and free it
             * (with g_free()) when it is done with it.
             */
            TAKE,
            /**
             * The passed-in data belongs to the caller; the
             * #SoupBuffer will copy it into new memory, leaving the caller free
             * to reuse the original memory.
             */
            COPY,
            /**
             * The passed-in data belongs to the caller,
             * but will remain valid for the lifetime of the #SoupBuffer. The
             * difference between this and `SOUP_MEMORY_STATIC` is that if you copy
             * a `SOUP_MEMORY_TEMPORARY` buffer, it will make a copy of the memory
             * as well, rather than reusing the original memory.
             */
            TEMPORARY,
        }
        /**
         * Value passed to soup_message_headers_new() to set certain default
         * behaviors.
         */

        /**
         * Value passed to soup_message_headers_new() to set certain default
         * behaviors.
         */
        export namespace MessageHeadersType {
            export const $gtype: GObject.GType<MessageHeadersType>;
        }

        enum MessageHeadersType {
            /**
             * request headers
             */
            REQUEST,
            /**
             * response headers
             */
            RESPONSE,
            /**
             * multipart body part headers
             */
            MULTIPART,
        }
        /**
         * Priorities that can be set on a #SoupMessage to instruct the
         * message queue to process it before any other message with lower
         * priority.
         */

        /**
         * Priorities that can be set on a #SoupMessage to instruct the
         * message queue to process it before any other message with lower
         * priority.
         */
        export namespace MessagePriority {
            export const $gtype: GObject.GType<MessagePriority>;
        }

        enum MessagePriority {
            /**
             * The lowest priority, the messages
             *   with this priority will be the last ones to be attended.
             */
            VERY_LOW,
            /**
             * Use this for low priority messages, a
             *   #SoupMessage with the default priority will be processed first.
             */
            LOW,
            /**
             * The default priotity, this is the
             *   priority assigned to the #SoupMessage by default.
             */
            NORMAL,
            /**
             * High priority, a #SoupMessage with
             *   this priority will be processed before the ones with the default
             *   priority.
             */
            HIGH,
            /**
             * The highest priority, use this
             *   for very urgent #SoupMessage as they will be the first ones to be
             *   attended.
             */
            VERY_HIGH,
        }
        /**
         * A #SoupRequest error.
         */
        class RequestError extends GLib.Error {
            static $gtype: GObject.GType<RequestError>;

            // Static fields

            /**
             * the URI could not be parsed
             */
            static BAD_URI: number;
            /**
             * the URI scheme is not
             *   supported by this #SoupSession
             */
            static UNSUPPORTED_URI_SCHEME: number;
            /**
             * the server's response could not
             *   be parsed
             */
            static PARSING: number;
            /**
             * the server's response was in an
             *   unsupported format
             */
            static ENCODING: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            static quark(): GLib.Quark;
        }

        class RequesterError extends GLib.Error {
            static $gtype: GObject.GType<RequesterError>;

            // Static fields

            static BAD_URI: number;
            static UNSUPPORTED_URI_SCHEME: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            static quark(): GLib.Quark;
        }

        export namespace SameSitePolicy {
            export const $gtype: GObject.GType<SameSitePolicy>;
        }

        enum SameSitePolicy {
            /**
             * The cookie is exposed with both cross-site and same-site requests
             */
            NONE,
            /**
             * The cookie is withheld on cross-site requests but exposed on cross-site navigations
             */
            LAX,
            /**
             * The cookie is only exposed for same-site requests
             */
            STRICT,
        }
        /**
         * Return value from the #SoupSocket IO methods.
         */

        /**
         * Return value from the #SoupSocket IO methods.
         */
        export namespace SocketIOStatus {
            export const $gtype: GObject.GType<SocketIOStatus>;
        }

        enum SocketIOStatus {
            /**
             * Success
             */
            OK,
            /**
             * Cannot read/write any more at this time
             */
            WOULD_BLOCK,
            /**
             * End of file
             */
            EOF,
            /**
             * Other error
             */
            ERROR,
        }
        /**
         * These represent the known HTTP status code values, plus various
         * network and internal errors.
         *
         * Note that no libsoup functions take or return this type directly;
         * any function that works with status codes will accept unrecognized
         * status codes as well.
         *
         * Prior to 2.44 this type was called
         * <literal>SoupKnownStatusCode</literal>, but the individual values
         * have always had the names they have now.
         */

        /**
         * These represent the known HTTP status code values, plus various
         * network and internal errors.
         *
         * Note that no libsoup functions take or return this type directly;
         * any function that works with status codes will accept unrecognized
         * status codes as well.
         *
         * Prior to 2.44 this type was called
         * <literal>SoupKnownStatusCode</literal>, but the individual values
         * have always had the names they have now.
         */
        export namespace Status {
            export const $gtype: GObject.GType<Status>;
        }

        enum Status {
            /**
             * No status available. (Eg, the message has not
             * been sent yet)
             */
            NONE,
            /**
             * Message was cancelled locally
             */
            CANCELLED,
            /**
             * Unable to resolve destination host name
             */
            CANT_RESOLVE,
            /**
             * Unable to resolve proxy host name
             */
            CANT_RESOLVE_PROXY,
            /**
             * Unable to connect to remote host
             */
            CANT_CONNECT,
            /**
             * Unable to connect to proxy
             */
            CANT_CONNECT_PROXY,
            /**
             * SSL/TLS negotiation failed
             */
            SSL_FAILED,
            /**
             * A network error occurred, or the other end
             * closed the connection unexpectedly
             */
            IO_ERROR,
            /**
             * Malformed data (usually a programmer error)
             */
            MALFORMED,
            /**
             * Used internally
             */
            TRY_AGAIN,
            /**
             * There were too many redirections
             */
            TOO_MANY_REDIRECTS,
            /**
             * Used internally
             */
            TLS_FAILED,
            /**
             * 100 Continue (HTTP)
             */
            CONTINUE,
            /**
             * 101 Switching Protocols (HTTP)
             */
            SWITCHING_PROTOCOLS,
            /**
             * 102 Processing (WebDAV)
             */
            PROCESSING,
            /**
             * 200 Success (HTTP). Also used by many lower-level
             * soup routines to indicate success.
             */
            OK,
            /**
             * 201 Created (HTTP)
             */
            CREATED,
            /**
             * 202 Accepted (HTTP)
             */
            ACCEPTED,
            /**
             * 203 Non-Authoritative Information
             * (HTTP)
             */
            NON_AUTHORITATIVE,
            /**
             * 204 No Content (HTTP)
             */
            NO_CONTENT,
            /**
             * 205 Reset Content (HTTP)
             */
            RESET_CONTENT,
            /**
             * 206 Partial Content (HTTP)
             */
            PARTIAL_CONTENT,
            /**
             * 207 Multi-Status (WebDAV)
             */
            MULTI_STATUS,
            /**
             * 300 Multiple Choices (HTTP)
             */
            MULTIPLE_CHOICES,
            /**
             * 301 Moved Permanently (HTTP)
             */
            MOVED_PERMANENTLY,
            /**
             * 302 Found (HTTP)
             */
            FOUND,
            /**
             * 302 Moved Temporarily (old name,
             * RFC 2068)
             */
            MOVED_TEMPORARILY,
            /**
             * 303 See Other (HTTP)
             */
            SEE_OTHER,
            /**
             * 304 Not Modified (HTTP)
             */
            NOT_MODIFIED,
            /**
             * 305 Use Proxy (HTTP)
             */
            USE_PROXY,
            /**
             * 306 [Unused] (HTTP)
             */
            NOT_APPEARING_IN_THIS_PROTOCOL,
            /**
             * 307 Temporary Redirect (HTTP)
             */
            TEMPORARY_REDIRECT,
            PERMANENT_REDIRECT,
            /**
             * 400 Bad Request (HTTP)
             */
            BAD_REQUEST,
            /**
             * 401 Unauthorized (HTTP)
             */
            UNAUTHORIZED,
            /**
             * 402 Payment Required (HTTP)
             */
            PAYMENT_REQUIRED,
            /**
             * 403 Forbidden (HTTP)
             */
            FORBIDDEN,
            /**
             * 404 Not Found (HTTP)
             */
            NOT_FOUND,
            /**
             * 405 Method Not Allowed (HTTP)
             */
            METHOD_NOT_ALLOWED,
            /**
             * 406 Not Acceptable (HTTP)
             */
            NOT_ACCEPTABLE,
            /**
             * 407 Proxy Authentication
             * Required (HTTP)
             */
            PROXY_AUTHENTICATION_REQUIRED,
            /**
             * shorter alias for
             * %SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED
             */
            PROXY_UNAUTHORIZED,
            /**
             * 408 Request Timeout (HTTP)
             */
            REQUEST_TIMEOUT,
            /**
             * 409 Conflict (HTTP)
             */
            CONFLICT,
            /**
             * 410 Gone (HTTP)
             */
            GONE,
            /**
             * 411 Length Required (HTTP)
             */
            LENGTH_REQUIRED,
            /**
             * 412 Precondition Failed (HTTP)
             */
            PRECONDITION_FAILED,
            /**
             * 413 Request Entity Too Large
             * (HTTP)
             */
            REQUEST_ENTITY_TOO_LARGE,
            /**
             * 414 Request-URI Too Long (HTTP)
             */
            REQUEST_URI_TOO_LONG,
            /**
             * 415 Unsupported Media Type
             * (HTTP)
             */
            UNSUPPORTED_MEDIA_TYPE,
            /**
             * 416 Requested Range
             * Not Satisfiable (HTTP)
             */
            REQUESTED_RANGE_NOT_SATISFIABLE,
            /**
             * shorter alias for
             * %SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE
             */
            INVALID_RANGE,
            /**
             * 417 Expectation Failed (HTTP)
             */
            EXPECTATION_FAILED,
            /**
             * 422 Unprocessable Entity
             * (WebDAV)
             */
            UNPROCESSABLE_ENTITY,
            /**
             * 423 Locked (WebDAV)
             */
            LOCKED,
            /**
             * 424 Failed Dependency (WebDAV)
             */
            FAILED_DEPENDENCY,
            /**
             * 500 Internal Server Error
             * (HTTP)
             */
            INTERNAL_SERVER_ERROR,
            /**
             * 501 Not Implemented (HTTP)
             */
            NOT_IMPLEMENTED,
            /**
             * 502 Bad Gateway (HTTP)
             */
            BAD_GATEWAY,
            /**
             * 503 Service Unavailable (HTTP)
             */
            SERVICE_UNAVAILABLE,
            /**
             * 504 Gateway Timeout (HTTP)
             */
            GATEWAY_TIMEOUT,
            /**
             * 505 HTTP Version Not
             * Supported (HTTP)
             */
            HTTP_VERSION_NOT_SUPPORTED,
            /**
             * 507 Insufficient Storage
             * (WebDAV)
             */
            INSUFFICIENT_STORAGE,
            /**
             * 510 Not Extended (RFC 2774)
             */
            NOT_EXTENDED,
        }
        /**
         * Error codes for %SOUP_TLD_ERROR.
         */
        class TLDError extends GLib.Error {
            static $gtype: GObject.GType<TLDError>;

            // Static fields

            /**
             * A hostname was syntactically
             *   invalid.
             */
            static INVALID_HOSTNAME: number;
            /**
             * The passed-in "hostname" was
             *   actually an IP address (and thus has no base domain or
             *   public suffix).
             */
            static IS_IP_ADDRESS: number;
            /**
             * The passed-in hostname
             *   did not have enough components. Eg, calling
             *   soup_tld_get_base_domain() on <literal>"co.uk"</literal>.
             */
            static NOT_ENOUGH_DOMAINS: number;
            /**
             * The passed-in hostname has
             *   no recognized public suffix.
             */
            static NO_BASE_DOMAIN: number;
            static NO_PSL_DATA: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            static quark(): GLib.Quark;
        }

        /**
         * Pre-defined close codes that can be passed to
         * soup_websocket_connection_close() or received from
         * soup_websocket_connection_get_close_code(). (However, other codes
         * are also allowed.)
         */

        /**
         * Pre-defined close codes that can be passed to
         * soup_websocket_connection_close() or received from
         * soup_websocket_connection_get_close_code(). (However, other codes
         * are also allowed.)
         */
        export namespace WebsocketCloseCode {
            export const $gtype: GObject.GType<WebsocketCloseCode>;
        }

        enum WebsocketCloseCode {
            /**
             * a normal, non-error close
             */
            NORMAL,
            /**
             * the client/server is going away
             */
            GOING_AWAY,
            /**
             * a protocol error occurred
             */
            PROTOCOL_ERROR,
            /**
             * the endpoint received data
             *   of a type that it does not support.
             */
            UNSUPPORTED_DATA,
            /**
             * reserved value indicating that
             *   no close code was present; must not be sent.
             */
            NO_STATUS,
            /**
             * reserved value indicating that
             *   the connection was closed abnormally; must not be sent.
             */
            ABNORMAL,
            /**
             * the endpoint received data that
             *   was invalid (eg, non-UTF-8 data in a text message).
             */
            BAD_DATA,
            /**
             * generic error code
             *   indicating some sort of policy violation.
             */
            POLICY_VIOLATION,
            /**
             * the endpoint received a message
             *   that is too big to process.
             */
            TOO_BIG,
            /**
             * the client is closing the
             *   connection because the server failed to negotiate a required
             *   extension.
             */
            NO_EXTENSION,
            /**
             * the server is closing the
             *   connection because it was unable to fulfill the request.
             */
            SERVER_ERROR,
            /**
             * reserved value indicating that
             *   the TLS handshake failed; must not be sent.
             */
            TLS_HANDSHAKE,
        }
        /**
         * The type of a #SoupWebsocketConnection.
         */

        /**
         * The type of a #SoupWebsocketConnection.
         */
        export namespace WebsocketConnectionType {
            export const $gtype: GObject.GType<WebsocketConnectionType>;
        }

        enum WebsocketConnectionType {
            /**
             * unknown/invalid connection
             */
            UNKNOWN,
            /**
             * a client-side connection
             */
            CLIENT,
            /**
             * a server-side connection
             */
            SERVER,
        }
        /**
         * The type of data contained in a #SoupWebsocketConnection::message
         * signal.
         */

        /**
         * The type of data contained in a #SoupWebsocketConnection::message
         * signal.
         */
        export namespace WebsocketDataType {
            export const $gtype: GObject.GType<WebsocketDataType>;
        }

        enum WebsocketDataType {
            /**
             * UTF-8 text
             */
            TEXT,
            /**
             * binary data
             */
            BINARY,
        }
        /**
         * WebSocket-related errors.
         */

        /**
         * WebSocket-related errors.
         */
        export namespace WebsocketError {
            export const $gtype: GObject.GType<WebsocketError>;
        }

        enum WebsocketError {
            /**
             * a generic error
             */
            FAILED,
            /**
             * attempted to handshake with a
             *   server that does not appear to understand WebSockets.
             */
            NOT_WEBSOCKET,
            /**
             * the WebSocket handshake failed
             *   because some detail was invalid (eg, incorrect accept key).
             */
            BAD_HANDSHAKE,
            /**
             * the WebSocket handshake failed
             *   because the "Origin" header was not an allowed value.
             */
            BAD_ORIGIN,
        }
        /**
         * The state of the WebSocket connection.
         */

        /**
         * The state of the WebSocket connection.
         */
        export namespace WebsocketState {
            export const $gtype: GObject.GType<WebsocketState>;
        }

        enum WebsocketState {
            /**
             * the connection is ready to send messages
             */
            OPEN,
            /**
             * the connection is in the process of
             *   closing down; messages may be received, but not sent
             */
            CLOSING,
            /**
             * the connection is completely closed down
             */
            CLOSED,
        }
        class XMLRPCError extends GLib.Error {
            static $gtype: GObject.GType<XMLRPCError>;

            // Static fields

            static ARGUMENTS: number;
            static RETVAL: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            static quark(): GLib.Quark;
        }

        /**
         * Pre-defined XML-RPC fault codes from <ulink
         * url="http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php">http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php</ulink>.
         * These are an extension, not part of the XML-RPC spec; you can't
         * assume servers will use them.
         */

        /**
         * Pre-defined XML-RPC fault codes from <ulink
         * url="http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php">http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php</ulink>.
         * These are an extension, not part of the XML-RPC spec; you can't
         * assume servers will use them.
         */
        export namespace XMLRPCFault {
            export const $gtype: GObject.GType<XMLRPCFault>;
        }

        enum XMLRPCFault {
            /**
             * request was not
             *   well-formed
             */
            PARSE_ERROR_NOT_WELL_FORMED,
            /**
             * request was in
             *   an unsupported encoding
             */
            PARSE_ERROR_UNSUPPORTED_ENCODING,
            /**
             * request contained an invalid character
             */
            PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING,
            /**
             * request was not
             *   valid XML-RPC
             */
            SERVER_ERROR_INVALID_XML_RPC,
            /**
             * method
             *   not found
             */
            SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND,
            /**
             * invalid
             *   parameters
             */
            SERVER_ERROR_INVALID_METHOD_PARAMETERS,
            /**
             * internal
             *   error
             */
            SERVER_ERROR_INTERNAL_XML_RPC_ERROR,
            /**
             * start of reserved range for
             *   application error codes
             */
            APPLICATION_ERROR,
            /**
             * start of reserved range for
             *   system error codes
             */
            SYSTEM_ERROR,
            /**
             * start of reserved range for
             *   transport error codes
             */
            TRANSPORT_ERROR,
        }
        /**
         * This can be passed to any #SoupAddress method that expects a port,
         * to indicate that you don't care what port is used.
         */
        const ADDRESS_ANY_PORT: number;
        /**
         * Alias for the #SoupAddress:family property. (The
         * #SoupAddressFamily for this address.)
         */
        const ADDRESS_FAMILY: string;
        /**
         * Alias for the #SoupAddress:name property. (The hostname for
         * this address.)
         */
        const ADDRESS_NAME: string;
        /**
         * An alias for the #SoupAddress:physical property. (The
         * stringified IP address for this address.)
         */
        const ADDRESS_PHYSICAL: string;
        /**
         * An alias for the #SoupAddress:port property. (The port for
         * this address.)
         */
        const ADDRESS_PORT: string;
        /**
         * Alias for the #SoupAddress:protocol property. (The URI scheme
         * used with this address.)
         */
        const ADDRESS_PROTOCOL: string;
        /**
         * An alias for the #SoupAddress:sockaddr property. (A pointer
         * to the struct sockaddr for this address.)
         */
        const ADDRESS_SOCKADDR: string;
        /**
         * Alias for the #SoupAuthDomain:add-path property. (Shortcut
         * for calling soup_auth_domain_add_path().)
         */
        const AUTH_DOMAIN_ADD_PATH: string;
        /**
         * Alias for the #SoupAuthDomainBasic:auth-callback property.
         * (The #SoupAuthDomainBasicAuthCallback.)
         */
        const AUTH_DOMAIN_BASIC_AUTH_CALLBACK: string;
        /**
         * Alias for the #SoupAuthDomainBasic:auth-data property.
         * (The data to pass to the #SoupAuthDomainBasicAuthCallback.)
         */
        const AUTH_DOMAIN_BASIC_AUTH_DATA: string;
        /**
         * Alias for the #SoupAuthDomainDigest:auth-callback property.
         * (The #SoupAuthDomainDigestAuthCallback.)
         */
        const AUTH_DOMAIN_DIGEST_AUTH_CALLBACK: string;
        /**
         * Alias for the #SoupAuthDomainDigest:auth-callback property.
         * (The #SoupAuthDomainDigestAuthCallback.)
         */
        const AUTH_DOMAIN_DIGEST_AUTH_DATA: string;
        /**
         * Alias for the #SoupAuthDomain:filter property. (The
         * #SoupAuthDomainFilter for the domain.)
         */
        const AUTH_DOMAIN_FILTER: string;
        /**
         * Alias for the #SoupAuthDomain:filter-data property. (Data
         * to pass to the #SoupAuthDomainFilter.)
         */
        const AUTH_DOMAIN_FILTER_DATA: string;
        /**
         * Alias for the #SoupAuthDomain:generic-auth-callback property.
         * (The #SoupAuthDomainGenericAuthCallback.)
         */
        const AUTH_DOMAIN_GENERIC_AUTH_CALLBACK: string;
        /**
         * Alias for the #SoupAuthDomain:generic-auth-data property.
         * (The data to pass to the #SoupAuthDomainGenericAuthCallback.)
         */
        const AUTH_DOMAIN_GENERIC_AUTH_DATA: string;
        /**
         * Alias for the #SoupAuthDomain:proxy property. (Whether or
         * not this is a proxy auth domain.)
         */
        const AUTH_DOMAIN_PROXY: string;
        /**
         * Alias for the #SoupAuthDomain:realm property. (The realm of
         * this auth domain.)
         */
        const AUTH_DOMAIN_REALM: string;
        /**
         * Alias for the #SoupAuthDomain:remove-path property.
         * (Shortcut for calling soup_auth_domain_remove_path().)
         */
        const AUTH_DOMAIN_REMOVE_PATH: string;
        /**
         * An alias for the #SoupAuth:host property. (The
         * host being authenticated to.)
         */
        const AUTH_HOST: string;
        /**
         * An alias for the #SoupAuth:is-authenticated property.
         * (Whether or not the auth has been authenticated.)
         */
        const AUTH_IS_AUTHENTICATED: string;
        /**
         * An alias for the #SoupAuth:is-for-proxy property. (Whether
         * or not the auth is for a proxy server.)
         */
        const AUTH_IS_FOR_PROXY: string;
        /**
         * An alias for the #SoupAuth:realm property. (The
         * authentication realm.)
         */
        const AUTH_REALM: string;
        /**
         * An alias for the #SoupAuth:scheme-name property. (The
         * authentication scheme name.)
         */
        const AUTH_SCHEME_NAME: string;
        const CHAR_HTTP_CTL: number;
        const CHAR_HTTP_SEPARATOR: number;
        const CHAR_URI_GEN_DELIMS: number;
        const CHAR_URI_PERCENT_ENCODED: number;
        const CHAR_URI_SUB_DELIMS: number;
        /**
         * Alias for the #SoupCookieJar:accept-policy property.
         */
        const COOKIE_JAR_ACCEPT_POLICY: string;
        /**
         * Alias for the #SoupCookieJarDB:filename property. (The
         * cookie-storage filename.)
         */
        const COOKIE_JAR_DB_FILENAME: string;
        /**
         * Alias for the #SoupCookieJar:read-only property. (Whether
         * or not the cookie jar is read-only.)
         */
        const COOKIE_JAR_READ_ONLY: string;
        /**
         * Alias for the #SoupCookieJarText:filename property. (The
         * cookie-storage filename.)
         */
        const COOKIE_JAR_TEXT_FILENAME: string;
        /**
         * A constant corresponding to 1 day, for use with soup_cookie_new()
         * and soup_cookie_set_max_age().
         */
        const COOKIE_MAX_AGE_ONE_DAY: number;
        /**
         * A constant corresponding to 1 hour, for use with soup_cookie_new()
         * and soup_cookie_set_max_age().
         */
        const COOKIE_MAX_AGE_ONE_HOUR: number;
        /**
         * A constant corresponding to 1 week, for use with soup_cookie_new()
         * and soup_cookie_set_max_age().
         */
        const COOKIE_MAX_AGE_ONE_WEEK: number;
        /**
         * A constant corresponding to 1 year, for use with soup_cookie_new()
         * and soup_cookie_set_max_age().
         */
        const COOKIE_MAX_AGE_ONE_YEAR: number;
        /**
         * A macro containing the value
         * <literal>"multipart/form-data"</literal>; the MIME type used for
         * posting form data that contains files to be uploaded.
         */
        const FORM_MIME_TYPE_MULTIPART: string;
        /**
         * A macro containing the value
         * <literal>"application/x-www-form-urlencoded"</literal>; the default
         * MIME type for POSTing HTML form data.
         */
        const FORM_MIME_TYPE_URLENCODED: string;
        const HSTS_ENFORCER_DB_FILENAME: string;
        const HSTS_POLICY_MAX_AGE_PAST: number;
        /**
         * Alias for the #SoupLogger:level property, qv.
         */
        const LOGGER_LEVEL: string;
        /**
         * Alias for the #SoupLogger:max-body-size property, qv.
         */
        const LOGGER_MAX_BODY_SIZE: string;
        /**
         * Like soup_get_major_version(), but from the headers used at
         * application compile time, rather than from the library linked
         * against at application run time.
         */
        const MAJOR_VERSION: number;
        /**
         * Alias for the #SoupMessage:first-party property. (The
         * #SoupURI loaded in the application when the message was
         * queued.)
         */
        const MESSAGE_FIRST_PARTY: string;
        /**
         * Alias for the #SoupMessage:flags property. (The message's
         * #SoupMessageFlags.)
         */
        const MESSAGE_FLAGS: string;
        /**
         * Alias for the #SoupMessage:http-version property. (The
         * message's #SoupHTTPVersion.)
         */
        const MESSAGE_HTTP_VERSION: string;
        const MESSAGE_IS_TOP_LEVEL_NAVIGATION: string;
        /**
         * Alias for the #SoupMessage:method property. (The message's
         * HTTP method.)
         */
        const MESSAGE_METHOD: string;
        /**
         * Sets the priority of the #SoupMessage. See
         * soup_message_set_priority() for further details.
         */
        const MESSAGE_PRIORITY: string;
        /**
         * Alias for the #SoupMessage:reason-phrase property. (The
         * message's HTTP response reason phrase.)
         */
        const MESSAGE_REASON_PHRASE: string;
        /**
         * Alias for the #SoupMessage:request-body property. (The
         * message's HTTP request body.)
         */
        const MESSAGE_REQUEST_BODY: string;
        /**
         * Alias for the #SoupMessage:request-body-data property. (The
         * message's HTTP request body, as a #GBytes.)
         */
        const MESSAGE_REQUEST_BODY_DATA: string;
        /**
         * Alias for the #SoupMessage:request-headers property. (The
         * message's HTTP request headers.)
         */
        const MESSAGE_REQUEST_HEADERS: string;
        /**
         * Alias for the #SoupMessage:response-body property. (The
         * message's HTTP response body.)
         */
        const MESSAGE_RESPONSE_BODY: string;
        /**
         * Alias for the #SoupMessage:response-body-data property. (The
         * message's HTTP response body, as a #GBytes.)
         */
        const MESSAGE_RESPONSE_BODY_DATA: string;
        /**
         * Alias for the #SoupMessage:response-headers property. (The
         * message's HTTP response headers.)
         */
        const MESSAGE_RESPONSE_HEADERS: string;
        /**
         * Alias for the #SoupMessage:server-side property. (%TRUE if
         * the message was created by #SoupServer.)
         */
        const MESSAGE_SERVER_SIDE: string;
        const MESSAGE_SITE_FOR_COOKIES: string;
        /**
         * Alias for the #SoupMessage:status-code property. (The
         * message's HTTP response status code.)
         */
        const MESSAGE_STATUS_CODE: string;
        /**
         * Alias for the #SoupMessage:tls-certificate property. (The
         * TLS certificate associated with the message, if any.)
         */
        const MESSAGE_TLS_CERTIFICATE: string;
        /**
         * Alias for the #SoupMessage:tls-errors property. (The
         * verification errors on #SoupMessage:tls-certificate.)
         */
        const MESSAGE_TLS_ERRORS: string;
        /**
         * Alias for the #SoupMessage:uri property. (The message's
         * #SoupURI.)
         */
        const MESSAGE_URI: string;
        /**
         * Like soup_get_micro_version(), but from the headers used at
         * application compile time, rather than from the library linked
         * against at application run time.
         */
        const MICRO_VERSION: number;
        /**
         * Like soup_get_minor_version(), but from the headers used at
         * application compile time, rather than from the library linked
         * against at application run time.
         */
        const MINOR_VERSION: number;
        /**
         * Alias for the #SoupRequest:session property, qv.
         */
        const REQUEST_SESSION: string;
        /**
         * Alias for the #SoupRequest:uri property, qv.
         */
        const REQUEST_URI: string;
        /**
         * Alias for the deprecated #SoupServer:async-context
         * property, qv.
         */
        const SERVER_ASYNC_CONTEXT: string;
        /**
         * Alias for the #SoupServer:https-aliases property, qv.
         */
        const SERVER_HTTPS_ALIASES: string;
        /**
         * Alias for the #SoupServer:http-aliases property, qv.
         */
        const SERVER_HTTP_ALIASES: string;
        /**
         * Alias for the #SoupServer:interface property, qv.
         */
        const SERVER_INTERFACE: string;
        /**
         * Alias for the deprecated #SoupServer:port property, qv.
         */
        const SERVER_PORT: string;
        /**
         * Alias for the #SoupServer:raw-paths property. (If %TRUE,
         * percent-encoding in the Request-URI path will not be
         * automatically decoded.)
         */
        const SERVER_RAW_PATHS: string;
        /**
         * Alias for the #SoupServer:server-header property, qv.
         */
        const SERVER_SERVER_HEADER: string;
        /**
         * Alias for the #SoupServer:ssl-cert-file property, qv.
         */
        const SERVER_SSL_CERT_FILE: string;
        /**
         * Alias for the #SoupServer:ssl-key-file property, qv.
         */
        const SERVER_SSL_KEY_FILE: string;
        /**
         * Alias for the #SoupServer:tls-certificate property, qv.
         */
        const SERVER_TLS_CERTIFICATE: string;
        /**
         * Alias for the #SoupSession:accept-language property, qv.
         */
        const SESSION_ACCEPT_LANGUAGE: string;
        /**
         * Alias for the #SoupSession:accept-language-auto property, qv.
         */
        const SESSION_ACCEPT_LANGUAGE_AUTO: string;
        /**
         * Alias for the #SoupSession:async-context property, qv.
         */
        const SESSION_ASYNC_CONTEXT: string;
        /**
         * Alias for the #SoupSession:https-aliases property, qv.
         */
        const SESSION_HTTPS_ALIASES: string;
        /**
         * Alias for the #SoupSession:http-aliases property, qv.
         */
        const SESSION_HTTP_ALIASES: string;
        /**
         * Alias for the #SoupSession:idle-timeout property, qv.
         */
        const SESSION_IDLE_TIMEOUT: string;
        /**
         * Alias for the #SoupSession:local-address property, qv.
         */
        const SESSION_LOCAL_ADDRESS: string;
        /**
         * Alias for the #SoupSession:max-conns property, qv.
         */
        const SESSION_MAX_CONNS: string;
        /**
         * Alias for the #SoupSession:max-conns-per-host property, qv.
         */
        const SESSION_MAX_CONNS_PER_HOST: string;
        /**
         * Alias for the #SoupSession:proxy-resolver property, qv.
         */
        const SESSION_PROXY_RESOLVER: string;
        /**
         * Alias for the #SoupSession:proxy-uri property, qv.
         */
        const SESSION_PROXY_URI: string;
        /**
         * Alias for the #SoupSession:ssl-ca-file property, qv.
         */
        const SESSION_SSL_CA_FILE: string;
        /**
         * Alias for the #SoupSession:ssl-strict property, qv.
         */
        const SESSION_SSL_STRICT: string;
        /**
         * Alias for the #SoupSession:ssl-use-system-ca-file property,
         * qv.
         */
        const SESSION_SSL_USE_SYSTEM_CA_FILE: string;
        /**
         * Alias for the #SoupSession:timeout property, qv.
         */
        const SESSION_TIMEOUT: string;
        /**
         * Alias for the #SoupSession:tls-database property, qv.
         */
        const SESSION_TLS_DATABASE: string;
        /**
         * Alias for the #SoupSession:tls-interaction property, qv.
         */
        const SESSION_TLS_INTERACTION: string;
        /**
         * Alias for the #SoupSession:user-agent property, qv.
         */
        const SESSION_USER_AGENT: string;
        /**
         * Alias for the #SoupSession:use-ntlm property, qv.
         */
        const SESSION_USE_NTLM: string;
        /**
         * Alias for the #SoupSession:use-thread-context property, qv.
         */
        const SESSION_USE_THREAD_CONTEXT: string;
        /**
         * Alias for the #SoupSocket:async-context property. (The
         * socket's #GMainContext.)
         */
        const SOCKET_ASYNC_CONTEXT: string;
        /**
         * Alias for the #SoupSocket:non-blocking property. (Whether
         * or not the socket uses non-blocking I/O.)
         */
        const SOCKET_FLAG_NONBLOCKING: string;
        /**
         * Alias for the #SoupSocket:is-server property, qv.
         */
        const SOCKET_IS_SERVER: string;
        /**
         * Alias for the #SoupSocket:local-address property. (Address
         * of local end of socket.)
         */
        const SOCKET_LOCAL_ADDRESS: string;
        /**
         * Alias for the #SoupSocket:remote-address property. (Address
         * of remote end of socket.)
         */
        const SOCKET_REMOTE_ADDRESS: string;
        /**
         * Alias for the #SoupSocket:ssl-creds property.
         * (SSL credential information.)
         */
        const SOCKET_SSL_CREDENTIALS: string;
        /**
         * Alias for the #SoupSocket:ssl-fallback property.
         */
        const SOCKET_SSL_FALLBACK: string;
        /**
         * Alias for the #SoupSocket:ssl-strict property.
         */
        const SOCKET_SSL_STRICT: string;
        /**
         * Alias for the #SoupSocket:timeout property. (The timeout
         * in seconds for blocking socket I/O operations.)
         */
        const SOCKET_TIMEOUT: string;
        /**
         * Alias for the #SoupSocket:tls-certificate
         * property. Note that this property's value is only useful
         * if the socket is for a TLS connection, and only reliable
         * after some data has been transferred to or from it.
         */
        const SOCKET_TLS_CERTIFICATE: string;
        /**
         * Alias for the #SoupSocket:tls-errors
         * property. Note that this property's value is only useful
         * if the socket is for a TLS connection, and only reliable
         * after some data has been transferred to or from it.
         */
        const SOCKET_TLS_ERRORS: string;
        /**
         * Alias for the #SoupSocket:trusted-certificate
         * property.
         */
        const SOCKET_TRUSTED_CERTIFICATE: string;
        /**
         * Alias for the #SoupSocket:use-thread-context property. (Use
         * g_main_context_get_thread_default())
         */
        const SOCKET_USE_THREAD_CONTEXT: string;
        /**
         * A macro that should be defined by the user prior to including
         * libsoup.h. The definition should be one of the predefined libsoup
         * version macros: %SOUP_VERSION_2_24, %SOUP_VERSION_2_26, ...
         *
         * This macro defines the earliest version of libsoup that the package
         * is required to be able to compile against.
         *
         * If the compiler is configured to warn about the use of deprecated
         * functions, then using functions that were deprecated in version
         * %SOUP_VERSION_MIN_REQUIRED or earlier will cause warnings (but
         * using functions deprecated in later releases will not).
         */
        const VERSION_MIN_REQUIRED: number;
        /**
         * Like SOUP_CHECK_VERSION, but the check for soup_check_version is
         * at runtime instead of compile time. This is useful for compiling
         * against older versions of libsoup, but using features from newer
         * versions.
         * @param major the major version to check
         * @param minor the minor version to check
         * @param micro the micro version to check
         * @returns %TRUE if the version of the libsoup currently loaded is the same as or newer than the passed-in version.
         */
        function check_version(major: number, minor: number, micro: number): boolean;
        /**
         * Parses `header` and returns a #SoupCookie. (If `header` contains
         * multiple cookies, only the first one will be parsed.)
         *
         * If `header` does not have "path" or "domain" attributes, they will
         * be defaulted from `origin`. If `origin` is %NULL, path will default
         * to "/", but domain will be left as %NULL. Note that this is not a
         * valid state for a #SoupCookie, and you will need to fill in some
         * appropriate string for the domain if you want to actually make use
         * of the cookie.
         * @param header a cookie string (eg, the value of a Set-Cookie header)
         * @param origin origin of the cookie, or %NULL
         * @returns a new #SoupCookie, or %NULL if it could not be parsed, or contained an illegal "domain" attribute for a cookie originating from @origin.
         */
        function cookie_parse(header: string, origin: URI): Cookie | null;
        /**
         * Parses `msg'`s Cookie request header and returns a #GSList of
         * #SoupCookie<!-- -->s. As the "Cookie" header, unlike "Set-Cookie",
         * only contains cookie names and values, none of the other
         * #SoupCookie fields will be filled in. (Thus, you can't generally
         * pass a cookie returned from this method directly to
         * soup_cookies_to_response().)
         * @param msg a #SoupMessage containing a "Cookie" request header
         * @returns a #GSList of #SoupCookie<!-- -->s, which can be freed with soup_cookies_free().
         */
        function cookies_from_request(msg: Message): Cookie[];
        /**
         * Parses `msg'`s Set-Cookie response headers and returns a #GSList of
         * #SoupCookie<!-- -->s. Cookies that do not specify "path" or
         * "domain" attributes will have their values defaulted from `msg`.
         * @param msg a #SoupMessage containing a "Set-Cookie" response header
         * @returns a #GSList of #SoupCookie<!-- -->s, which can be freed with soup_cookies_free().
         */
        function cookies_from_response(msg: Message): Cookie[];
        /**
         * Serializes a #GSList of #SoupCookie into a string suitable for
         * setting as the value of the "Cookie" header.
         * @param cookies a #GSList of #SoupCookie
         * @returns the serialization of @cookies
         */
        function cookies_to_cookie_header(cookies: Cookie[]): string;
        /**
         * Adds the name and value of each cookie in `cookies` to `msg'`s
         * "Cookie" request. (If `msg` already has a "Cookie" request header,
         * these cookies will be appended to the cookies already present. Be
         * careful that you do not append the same cookies twice, eg, when
         * requeuing a message.)
         * @param cookies a #GSList of #SoupCookie
         * @param msg a #SoupMessage
         */
        function cookies_to_request(cookies: Cookie[], msg: Message): void;
        /**
         * Appends a "Set-Cookie" response header to `msg` for each cookie in
         * `cookies`. (This is in addition to any other "Set-Cookie" headers
         * `msg` may already have.)
         * @param cookies a #GSList of #SoupCookie
         * @param msg a #SoupMessage
         */
        function cookies_to_response(cookies: Cookie[], msg: Message): void;
        /**
         * Decodes `form,` which is an urlencoded dataset as defined in the
         * HTML 4.01 spec.
         * @param encoded_form data of type "application/x-www-form-urlencoded"
         * @returns a hash table containing the name/value pairs from @encoded_form, which you can free with g_hash_table_destroy().
         */
        function form_decode(encoded_form: string): GLib.HashTable<string, string>;
        /**
         * Decodes the "multipart/form-data" request in `msg;` this is a
         * convenience method for the case when you have a single file upload
         * control in a form. (Or when you don't have any file upload
         * controls, but are still using "multipart/form-data" anyway.) Pass
         * the name of the file upload control in `file_control_name,` and
         * soup_form_decode_multipart() will extract the uploaded file data
         * into `filename,` `content_type,` and `file`. All of the other form
         * control data will be returned (as strings, as with
         * soup_form_decode()) in the returned #GHashTable.
         *
         * You may pass %NULL for `filename,` `content_type` and/or `file` if you do not
         * care about those fields. soup_form_decode_multipart() may also
         * return %NULL in those fields if the client did not provide that
         * information. You must free the returned filename and content-type
         * with g_free(), and the returned file data with soup_buffer_free().
         *
         * If you have a form with more than one file upload control, you will
         * need to decode it manually, using soup_multipart_new_from_message()
         * and soup_multipart_get_part().
         * @param msg a #SoupMessage containing a "multipart/form-data" request body
         * @param file_control_name the name of the HTML file upload control, or %NULL
         * @returns a hash table containing the name/value pairs (other than @file_control_name) from @msg, which you can free with g_hash_table_destroy(). On error, it will return %NULL.
         */
        function form_decode_multipart(
            msg: Message,
            file_control_name: string | null,
        ): [GLib.HashTable<string, string> | null, string, string, Buffer | null];
        /**
         * Encodes `form_data_set` into a value of type
         * "application/x-www-form-urlencoded", as defined in the HTML 4.01
         * spec. Unlike soup_form_encode_hash(), this preserves the ordering
         * of the form elements, which may be required in some situations.
         * @param form_data_set a datalist containing name/value pairs
         * @returns the encoded form
         */
        function form_encode_datalist(form_data_set: GLib.Data): string;
        /**
         * Encodes `form_data_set` into a value of type
         * "application/x-www-form-urlencoded", as defined in the HTML 4.01
         * spec.
         *
         * Note that the HTML spec states that "The control names/values are
         * listed in the order they appear in the document." Since this method
         * takes a hash table, it cannot enforce that; if you care about the
         * ordering of the form fields, use soup_form_encode_datalist().
         * @param form_data_set a hash table containing name/value pairs (as strings)
         * @returns the encoded form
         */
        function form_encode_hash(form_data_set: { [key: string]: any } | GLib.HashTable<string, string>): string;
        /**
         * Creates a new %SoupMessage and sets it up to send `form_data_set` to
         * `uri` via `method,` as with soup_form_request_new().
         * @param method the HTTP method, either "GET" or "POST"
         * @param uri the URI to send the form data to
         * @param form_data_set the data to send to @uri
         * @returns the new %SoupMessage
         */
        function form_request_new_from_datalist(method: string, uri: string, form_data_set: GLib.Data): Message;
        /**
         * Creates a new %SoupMessage and sets it up to send `form_data_set` to
         * `uri` via `method,` as with soup_form_request_new().
         * @param method the HTTP method, either "GET" or "POST"
         * @param uri the URI to send the form data to
         * @param form_data_set the data to send to @uri
         * @returns the new %SoupMessage
         */
        function form_request_new_from_hash(
            method: string,
            uri: string,
            form_data_set: { [key: string]: any } | GLib.HashTable<string, string>,
        ): Message;
        /**
         * Creates a new %SoupMessage and sets it up to send `multipart` to
         * `uri` via POST.
         *
         * To send a <literal>"multipart/form-data"</literal> POST, first
         * create a #SoupMultipart, using %SOUP_FORM_MIME_TYPE_MULTIPART as
         * the MIME type. Then use soup_multipart_append_form_string() and
         * soup_multipart_append_form_file() to add the value of each form
         * control to the multipart. (These are just convenience methods, and
         * you can use soup_multipart_append_part() if you need greater
         * control over the part headers.) Finally, call
         * soup_form_request_new_from_multipart() to serialize the multipart
         * structure and create a #SoupMessage.
         * @param uri the URI to send the form data to
         * @param multipart a "multipart/form-data" #SoupMultipart
         * @returns the new %SoupMessage
         */
        function form_request_new_from_multipart(uri: string, multipart: Multipart): Message;
        /**
         * Returns the major version number of the libsoup library.
         * (e.g. in libsoup version 2.42.0 this is 2.)
         *
         * This function is in the library, so it represents the libsoup library
         * your code is running against. Contrast with the #SOUP_MAJOR_VERSION
         * macro, which represents the major version of the libsoup headers you
         * have included when compiling your code.
         * @returns the major version number of the libsoup library
         */
        function get_major_version(): number;
        /**
         * Returns the micro version number of the libsoup library.
         * (e.g. in libsoup version 2.42.0 this is 0.)
         *
         * This function is in the library, so it represents the libsoup library
         * your code is running against. Contrast with the #SOUP_MICRO_VERSION
         * macro, which represents the micro version of the libsoup headers you
         * have included when compiling your code.
         * @returns the micro version number of the libsoup library
         */
        function get_micro_version(): number;
        /**
         * Returns the minor version number of the libsoup library.
         * (e.g. in libsoup version 2.42.0 this is 42.)
         *
         * This function is in the library, so it represents the libsoup library
         * your code is running against. Contrast with the #SOUP_MINOR_VERSION
         * macro, which represents the minor version of the libsoup headers you
         * have included when compiling your code.
         * @returns the minor version number of the libsoup library
         */
        function get_minor_version(): number;
        function get_resource(): Gio.Resource;
        /**
         * Parses `header` to see if it contains the token `token` (matched
         * case-insensitively). Note that this can't be used with lists
         * that have qvalues.
         * @param header An HTTP header suitable for parsing with soup_header_parse_list()
         * @param token a token
         * @returns whether or not @header contains @token
         */
        function header_contains(header: string, token: string): boolean;
        /**
         * Frees `param_list`.
         * @param param_list a #GHashTable returned from soup_header_parse_param_list() or soup_header_parse_semi_param_list()
         */
        function header_free_param_list(param_list: { [key: string]: any } | GLib.HashTable<string, string>): void;
        /**
         * Appends something like <literal>`name=``value<`/literal> to `string,`
         * taking care to quote `value` if needed, and if so, to escape any
         * quotes or backslashes in `value`.
         *
         * Alternatively, if `value` is a non-ASCII UTF-8 string, it will be
         * appended using RFC5987 syntax. Although in theory this is supposed
         * to work anywhere in HTTP that uses this style of parameter, in
         * reality, it can only be used portably with the Content-Disposition
         * "filename" parameter.
         *
         * If `value` is %NULL, this will just append `name` to `string`.
         * @param string a #GString being used to construct an HTTP header value
         * @param name a parameter name
         * @param value a parameter value, or %NULL
         */
        function header_g_string_append_param(string: GLib.String, name: string, value: string): void;
        /**
         * Appends something like <literal>`name=`"`value"`</literal> to
         * `string,` taking care to escape any quotes or backslashes in `value`.
         *
         * If `value` is (non-ASCII) UTF-8, this will instead use RFC 5987
         * encoding, just like soup_header_g_string_append_param().
         * @param string a #GString being used to construct an HTTP header value
         * @param name a parameter name
         * @param value a parameter value
         */
        function header_g_string_append_param_quoted(string: GLib.String, name: string, value: string): void;
        /**
         * Parses a header whose content is described by RFC2616 as
         * "#something", where "something" does not itself contain commas,
         * except as part of quoted-strings.
         * @param header a header value
         * @returns a #GSList of list elements, as allocated strings
         */
        function header_parse_list(header: string): string[];
        /**
         * Parses a header which is a comma-delimited list of something like:
         * <literal>token [ "=" ( token | quoted-string ) ]</literal>.
         *
         * Tokens that don't have an associated value will still be added to
         * the resulting hash table, but with a %NULL value.
         *
         * This also handles RFC5987 encoding (which in HTTP is mostly used
         * for giving UTF8-encoded filenames in the Content-Disposition
         * header).
         * @param header a header value
         * @returns a #GHashTable of list elements, which can be freed with soup_header_free_param_list().
         */
        function header_parse_param_list(header: string): GLib.HashTable<string, string>;
        /**
         * A strict version of soup_header_parse_param_list()
         * that bails out if there are duplicate parameters.
         * Note that this function will treat RFC5987-encoded
         * parameters as duplicated if an ASCII version is also
         * present. For header fields that might contain
         * RFC5987-encoded parameters, use
         * soup_header_parse_param_list() instead.
         * @param header a header value
         * @returns a #GHashTable of list elements, which can be freed with soup_header_free_param_list() or %NULL if there are duplicate elements.
         */
        function header_parse_param_list_strict(header: string): GLib.HashTable<string, string> | null;
        /**
         * Parses a header whose content is a list of items with optional
         * "qvalue"s (eg, Accept, Accept-Charset, Accept-Encoding,
         * Accept-Language, TE).
         *
         * If `unacceptable` is not %NULL, then on return, it will contain the
         * items with qvalue 0. Either way, those items will be removed from
         * the main list.
         * @param header a header value
         * @returns a #GSList of acceptable values (as allocated strings), highest-qvalue first.
         */
        function header_parse_quality_list(header: string): [string[], string[] | null];
        /**
         * Parses a header which is a semicolon-delimited list of something
         * like: <literal>token [ "=" ( token | quoted-string ) ]</literal>.
         *
         * Tokens that don't have an associated value will still be added to
         * the resulting hash table, but with a %NULL value.
         *
         * This also handles RFC5987 encoding (which in HTTP is mostly used
         * for giving UTF8-encoded filenames in the Content-Disposition
         * header).
         * @param header a header value
         * @returns a #GHashTable of list elements, which can be freed with soup_header_free_param_list().
         */
        function header_parse_semi_param_list(header: string): GLib.HashTable<string, string>;
        /**
         * A strict version of soup_header_parse_semi_param_list()
         * that bails out if there are duplicate parameters.
         * Note that this function will treat RFC5987-encoded
         * parameters as duplicated if an ASCII version is also
         * present. For header fields that might contain
         * RFC5987-encoded parameters, use
         * soup_header_parse_semi_param_list() instead.
         * @param header a header value
         * @returns a #GHashTable of list elements, which can be freed with soup_header_free_param_list() or %NULL if there are duplicate elements.
         */
        function header_parse_semi_param_list_strict(header: string): GLib.HashTable<string, string> | null;
        /**
         * Parses the headers of an HTTP request or response in `str` and
         * stores the results in `dest`. Beware that `dest` may be modified even
         * on failure.
         *
         * This is a low-level method; normally you would use
         * soup_headers_parse_request() or soup_headers_parse_response().
         * @param str the header string (including the Request-Line or Status-Line,   but not the trailing blank line)
         * @param len length of @str
         * @param dest #SoupMessageHeaders to store the header values in
         * @returns success or failure
         */
        function headers_parse(str: string, len: number, dest: MessageHeaders): boolean;
        /**
         * Parses the headers of an HTTP request in `str` and stores the
         * results in `req_method,` `req_path,` `ver,` and `req_headers`.
         *
         * Beware that `req_headers` may be modified even on failure.
         * @param str the headers (up to, but not including, the trailing blank line)
         * @param len length of @str
         * @param req_headers #SoupMessageHeaders to store the header values in
         * @returns %SOUP_STATUS_OK if the headers could be parsed, or an HTTP error to be returned to the client if they could not be.
         */
        function headers_parse_request(
            str: string,
            len: number,
            req_headers: MessageHeaders,
        ): [number, string, string, HTTPVersion | null];
        /**
         * Parses the headers of an HTTP response in `str` and stores the
         * results in `ver,` `status_code,` `reason_phrase,` and `headers`.
         *
         * Beware that `headers` may be modified even on failure.
         * @param str the headers (up to, but not including, the trailing blank line)
         * @param len length of @str
         * @param headers #SoupMessageHeaders to store the header values in
         * @returns success or failure.
         */
        function headers_parse_response(
            str: string,
            len: number,
            headers: MessageHeaders,
        ): [boolean, HTTPVersion | null, number, string];
        /**
         * Parses the HTTP Status-Line string in `status_line` into `ver,`
         * `status_code,` and `reason_phrase`. `status_line` must be terminated by
         * either "\0" or "\r\n".
         * @param status_line an HTTP Status-Line
         * @returns %TRUE if @status_line was parsed successfully.
         */
        function headers_parse_status_line(status_line: string): [boolean, HTTPVersion | null, number, string];
        function http_error_quark(): GLib.Quark;
        /**
         * Initializes `iter` for iterating `hdrs`.
         * @param hdrs a %SoupMessageHeaders
         */
        function message_headers_iter_init(hdrs: MessageHeaders): MessageHeadersIter;
        /**
         * Yields the next name/value pair in the %SoupMessageHeaders being
         * iterated by `iter`. If `iter` has already yielded the last header,
         * then soup_message_headers_iter_next() will return %FALSE and `name`
         * and `value` will be unchanged.
         * @param iter a %SoupMessageHeadersIter
         * @returns %TRUE if another name and value were returned, %FALSE if the end of the headers has been reached.
         */
        function message_headers_iter_next(iter: MessageHeadersIter): [boolean, MessageHeadersIter, string, string];
        function request_error_quark(): GLib.Quark;
        function requester_error_quark(): GLib.Quark;
        /**
         * Looks up the stock HTTP description of `status_code`. This is used
         * by soup_message_set_status() to get the correct text to go with a
         * given status code.
         *
         * <emphasis>There is no reason for you to ever use this
         * function.</emphasis> If you wanted the textual description for the
         * #SoupMessage:status_code of a given #SoupMessage, you should just
         * look at the message's #SoupMessage:reason_phrase. However, you
         * should only do that for use in debugging messages; HTTP reason
         * phrases are not localized, and are not generally very descriptive
         * anyway, and so they should never be presented to the user directly.
         * Instead, you should create you own error messages based on the
         * status code, and on what you were trying to do.
         * @param status_code an HTTP status code
         * @returns the (terse, English) description of @status_code
         */
        function status_get_phrase(status_code: number): string;
        /**
         * Turns %SOUP_STATUS_CANT_RESOLVE into
         * %SOUP_STATUS_CANT_RESOLVE_PROXY and %SOUP_STATUS_CANT_CONNECT into
         * %SOUP_STATUS_CANT_CONNECT_PROXY. Other status codes are passed
         * through unchanged.
         * @param status_code a status code
         * @returns the "proxified" equivalent of @status_code.
         */
        function status_proxify(status_code: number): number;
        /**
         * Compares `v1` and `v2` in a case-insensitive manner
         * @param v1 an ASCII string
         * @param v2 another ASCII string
         * @returns %TRUE if they are equal (modulo case)
         */
        function str_case_equal(v1?: any | null, v2?: any | null): boolean;
        /**
         * Hashes `key` in a case-insensitive manner.
         * @param key ASCII string to hash
         * @returns the hash code.
         */
        function str_case_hash(key?: any | null): number;
        /**
         * Looks whether the `domain` passed as argument is a public domain
         * suffix (.org, .com, .co.uk, etc) or not.
         *
         * Prior to libsoup 2.46, this function required that `domain` be in
         * UTF-8 if it was an IDN. From 2.46 on, the name can be in either
         * UTF-8 or ASCII format.
         * @param domain a domain name
         * @returns %TRUE if it is a public domain, %FALSE otherwise.
         */
        function tld_domain_is_public_suffix(domain: string): boolean;
        function tld_error_quark(): GLib.Quark;
        /**
         * Finds the base domain for a given `hostname`. The base domain is
         * composed by the top level domain (such as .org, .com, .co.uk, etc)
         * plus the second level domain, for example for myhost.mydomain.com
         * it will return mydomain.com.
         *
         * Note that %NULL will be returned for private URLs (those not ending
         * with any well known TLD) because choosing a base domain for them
         * would be totally arbitrary.
         *
         * Prior to libsoup 2.46, this function required that `hostname` be in
         * UTF-8 if it was an IDN. From 2.46 on, the name can be in either
         * UTF-8 or ASCII format (and the return value will be in the same
         * format).
         * @param hostname a hostname
         * @returns a pointer to the start of the base domain in @hostname. If an error occurs, %NULL will be returned and @error set.
         */
        function tld_get_base_domain(hostname: string): string;
        /**
         * Fully %<!-- -->-decodes `part`.
         *
         * In the past, this would return %NULL if `part` contained invalid
         * percent-encoding, but now it just ignores the problem (as
         * soup_uri_new() already did).
         * @param part a URI part
         * @returns the decoded URI part.
         */
        function uri_decode(part: string): string;
        /**
         * This %<!-- -->-encodes the given URI part and returns the escaped
         * version in allocated memory, which the caller must free when it is
         * done.
         * @param part a URI part
         * @param escape_extra additional reserved characters to escape (or %NULL)
         * @returns the encoded URI part
         */
        function uri_encode(part: string, escape_extra?: string | null): string;
        /**
         * %<!-- -->-decodes any "unreserved" characters (or characters in
         * `unescape_extra)` in `part,` and %<!-- -->-encodes any non-ASCII
         * characters, spaces, and non-printing characters in `part`.
         *
         * "Unreserved" characters are those that are not allowed to be used
         * for punctuation according to the URI spec. For example, letters are
         * unreserved, so soup_uri_normalize() will turn
         * <literal>http://example.com/foo/b%<!-- -->61r</literal> into
         * <literal>http://example.com/foo/bar</literal>, which is guaranteed
         * to mean the same thing. However, "/" is "reserved", so
         * <literal>http://example.com/foo%<!-- -->2Fbar</literal> would not
         * be changed, because it might mean something different to the
         * server.
         *
         * In the past, this would return %NULL if `part` contained invalid
         * percent-encoding, but now it just ignores the problem (as
         * soup_uri_new() already did).
         * @param part a URI part
         * @param unescape_extra reserved characters to unescape (or %NULL)
         * @returns the normalized URI part
         */
        function uri_normalize(part: string, unescape_extra?: string | null): string;
        /**
         * Creates a new %GValueArray. (This is just a wrapper around
         * g_value_array_new(), for naming consistency purposes.)
         * @returns a new %GValueArray
         */
        function value_array_new(): GObject.ValueArray;
        /**
         * Inserts `value` into `hash`. (Unlike with g_hash_table_insert(), both
         * the key and the value are copied).
         * @param hash a value hash
         * @param key the key
         * @param value a value
         */
        function value_hash_insert_value(
            hash: { [key: string]: any } | GLib.HashTable<string, GObject.Value>,
            key: string,
            value: GObject.Value | any,
        ): void;
        /**
         * Creates a #GHashTable whose keys are strings and whose values
         * are #GValue.
         * @returns a new empty #GHashTable
         */
        function value_hash_new(): GLib.HashTable<string, GObject.Value>;
        /**
         * Adds the necessary headers to `msg` to request a WebSocket
         * handshake. The message body and non-WebSocket-related headers are
         * not modified.
         *
         * Use soup_websocket_client_prepare_handshake_with_extensions() if you
         * want to include "Sec-WebSocket-Extensions" header in the request.
         *
         * This is a low-level function; if you use
         * soup_session_websocket_connect_async() to create a WebSocket
         * connection, it will call this for you.
         * @param msg a #SoupMessage
         * @param origin the "Origin" header to set
         * @param protocols list of   protocols to offer
         */
        function websocket_client_prepare_handshake(
            msg: Message,
            origin?: string | null,
            protocols?: string[] | null,
        ): void;
        /**
         * Adds the necessary headers to `msg` to request a WebSocket
         * handshake including supported WebSocket extensions.
         * The message body and non-WebSocket-related headers are
         * not modified.
         *
         * This is a low-level function; if you use
         * soup_session_websocket_connect_async() to create a WebSocket
         * connection, it will call this for you.
         * @param msg a #SoupMessage
         * @param origin the "Origin" header to set
         * @param protocols list of   protocols to offer
         * @param supported_extensions list   of supported extension types
         */
        function websocket_client_prepare_handshake_with_extensions(
            msg: Message,
            origin?: string | null,
            protocols?: string[] | null,
            supported_extensions?: GObject.TypeClass[] | null,
        ): void;
        /**
         * Looks at the response status code and headers in `msg` and
         * determines if they contain a valid WebSocket handshake response
         * (given the handshake request in `msg'`s request headers).
         *
         * If the response contains the "Sec-WebSocket-Extensions" header,
         * the handshake will be considered invalid. You need to use
         * soup_websocket_client_verify_handshake_with_extensions() to handle
         * responses with extensions.
         *
         * This is a low-level function; if you use
         * soup_session_websocket_connect_async() to create a WebSocket
         * connection, it will call this for you.
         * @param msg #SoupMessage containing both client and server sides of a   WebSocket handshake
         * @returns %TRUE if @msg contains a completed valid WebSocket   handshake, %FALSE and an error if not.
         */
        function websocket_client_verify_handshake(msg: Message): boolean;
        /**
         * Looks at the response status code and headers in `msg` and
         * determines if they contain a valid WebSocket handshake response
         * (given the handshake request in `msg'`s request headers).
         *
         * If `supported_extensions` is non-%NULL, extensions included in the
         * response "Sec-WebSocket-Extensions" are verified too. Accepted
         * extensions are returned in `accepted_extensions` parameter if non-%NULL.
         *
         * This is a low-level function; if you use
         * soup_session_websocket_connect_async() to create a WebSocket
         * connection, it will call this for you.
         * @param msg #SoupMessage containing both client and server sides of a   WebSocket handshake
         * @param supported_extensions list   of supported extension types
         * @returns %TRUE if @msg contains a completed valid WebSocket   handshake, %FALSE and an error if not.
         */
        function websocket_client_verify_handshake_with_extensions(
            msg: Message,
            supported_extensions?: GObject.TypeClass[] | null,
        ): [boolean, WebsocketExtension[] | null];
        function websocket_error_get_quark(): GLib.Quark;
        /**
         * Examines the method and request headers in `msg` and determines
         * whether `msg` contains a valid handshake request.
         *
         * If `origin` is non-%NULL, then only requests containing a matching
         * "Origin" header will be accepted. If `protocols` is non-%NULL, then
         * only requests containing a compatible "Sec-WebSocket-Protocols"
         * header will be accepted.
         *
         * Requests containing "Sec-WebSocket-Extensions" header will be
         * accepted even if the header is not valid. To check a request
         * with extensions you need to use
         * soup_websocket_server_check_handshake_with_extensions() and provide
         * the list of supported extension types.
         *
         * Normally soup_websocket_server_process_handshake() will take care
         * of this for you, and if you use soup_server_add_websocket_handler()
         * to handle accepting WebSocket connections, it will call that for
         * you. However, this function may be useful if you need to perform
         * more complicated validation; eg, accepting multiple different Origins,
         * or handling different protocols depending on the path.
         * @param msg #SoupMessage containing the client side of a WebSocket handshake
         * @param origin expected Origin header
         * @param protocols allowed WebSocket   protocols.
         * @returns %TRUE if @msg contained a valid WebSocket handshake,   %FALSE and an error if not.
         */
        function websocket_server_check_handshake(
            msg: Message,
            origin?: string | null,
            protocols?: string[] | null,
        ): boolean;
        /**
         * Examines the method and request headers in `msg` and determines
         * whether `msg` contains a valid handshake request.
         *
         * If `origin` is non-%NULL, then only requests containing a matching
         * "Origin" header will be accepted. If `protocols` is non-%NULL, then
         * only requests containing a compatible "Sec-WebSocket-Protocols"
         * header will be accepted. If `supported_extensions` is non-%NULL, then
         * only requests containing valid supported extensions in
         * "Sec-WebSocket-Extensions" header will be accepted.
         *
         * Normally soup_websocket_server_process_handshake_with_extensioins()
         * will take care of this for you, and if you use
         * soup_server_add_websocket_handler() to handle accepting WebSocket
         * connections, it will call that for you. However, this function may
         * be useful if you need to perform more complicated validation; eg,
         * accepting multiple different Origins, or handling different protocols
         * depending on the path.
         * @param msg #SoupMessage containing the client side of a WebSocket handshake
         * @param origin expected Origin header
         * @param protocols allowed WebSocket   protocols.
         * @param supported_extensions list   of supported extension types
         * @returns %TRUE if @msg contained a valid WebSocket handshake,   %FALSE and an error if not.
         */
        function websocket_server_check_handshake_with_extensions(
            msg: Message,
            origin?: string | null,
            protocols?: string[] | null,
            supported_extensions?: GObject.TypeClass[] | null,
        ): boolean;
        /**
         * Examines the method and request headers in `msg` and (assuming `msg`
         * contains a valid handshake request), fills in the handshake
         * response.
         *
         * If `expected_origin` is non-%NULL, then only requests containing a matching
         * "Origin" header will be accepted. If `protocols` is non-%NULL, then
         * only requests containing a compatible "Sec-WebSocket-Protocols"
         * header will be accepted.
         *
         * Requests containing "Sec-WebSocket-Extensions" header will be
         * accepted even if the header is not valid. To process a request
         * with extensions you need to use
         * soup_websocket_server_process_handshake_with_extensions() and provide
         * the list of supported extension types.
         *
         * This is a low-level function; if you use
         * soup_server_add_websocket_handler() to handle accepting WebSocket
         * connections, it will call this for you.
         * @param msg #SoupMessage containing the client side of a WebSocket handshake
         * @param expected_origin expected Origin header
         * @param protocols allowed WebSocket   protocols.
         * @returns %TRUE if @msg contained a valid WebSocket handshake   request and was updated to contain a handshake response. %FALSE if not.
         */
        function websocket_server_process_handshake(
            msg: Message,
            expected_origin?: string | null,
            protocols?: string[] | null,
        ): boolean;
        /**
         * Examines the method and request headers in `msg` and (assuming `msg`
         * contains a valid handshake request), fills in the handshake
         * response.
         *
         * If `expected_origin` is non-%NULL, then only requests containing a matching
         * "Origin" header will be accepted. If `protocols` is non-%NULL, then
         * only requests containing a compatible "Sec-WebSocket-Protocols"
         * header will be accepted. If `supported_extensions` is non-%NULL, then
         * only requests containing valid supported extensions in
         * "Sec-WebSocket-Extensions" header will be accepted. The accepted extensions
         * will be returned in `accepted_extensions` parameter if non-%NULL.
         *
         * This is a low-level function; if you use
         * soup_server_add_websocket_handler() to handle accepting WebSocket
         * connections, it will call this for you.
         * @param msg #SoupMessage containing the client side of a WebSocket handshake
         * @param expected_origin expected Origin header
         * @param protocols allowed WebSocket   protocols.
         * @param supported_extensions list   of supported extension types
         * @returns %TRUE if @msg contained a valid WebSocket handshake   request and was updated to contain a handshake response. %FALSE if not.
         */
        function websocket_server_process_handshake_with_extensions(
            msg: Message,
            expected_origin?: string | null,
            protocols?: string[] | null,
            supported_extensions?: GObject.TypeClass[] | null,
        ): [boolean, WebsocketExtension[] | null];
        /**
         * This creates an XML-RPC methodCall and returns it as a string.
         * This is the low-level method that soup_xmlrpc_request_new() is
         * built on.
         *
         * `params` is an array of #GValue representing the parameters to
         * `method`. (It is *not* a #GValueArray, although if you have a
         * #GValueArray, you can just pass its <literal>values</literal>f and
         * <literal>n_values</literal> fields.)
         *
         * The correspondence between glib types and XML-RPC types is:
         *
         *   int: #int (%G_TYPE_INT)
         *   boolean: #gboolean (%G_TYPE_BOOLEAN)
         *   string: #char* (%G_TYPE_STRING)
         *   double: #double (%G_TYPE_DOUBLE)
         *   datetime.iso8601: #SoupDate (%SOUP_TYPE_DATE)
         *   base64: #GByteArray (%SOUP_TYPE_BYTE_ARRAY)
         *   struct: #GHashTable (%G_TYPE_HASH_TABLE)
         *   array: #GValueArray (%G_TYPE_VALUE_ARRAY)
         *
         * For structs, use a #GHashTable that maps strings to #GValue;
         * soup_value_hash_new() and related methods can help with this.
         * @param method_name the name of the XML-RPC method
         * @param params arguments to @method
         * @returns the text of the methodCall, or %NULL on error
         */
        function xmlrpc_build_method_call(method_name: string, params: (GObject.Value | any)[]): string | null;
        /**
         * This creates a (successful) XML-RPC methodResponse and returns it
         * as a string. To create a fault response, use
         * soup_xmlrpc_build_fault().
         *
         * The glib type to XML-RPC type mapping is as with
         * soup_xmlrpc_build_method_call(), qv.
         * @param value the return value
         * @returns the text of the methodResponse, or %NULL on error
         */
        function xmlrpc_build_method_response(value: GObject.Value | any): string | null;
        /**
         * This creates an XML-RPC methodCall and returns it as a string.
         * This is the low-level method that soup_xmlrpc_message_new() is
         * built on.
         *
         * `params` is a #GVariant tuple representing the method parameters.
         *
         * Serialization details:
         *  - "a{s*}" and "{s*}" are serialized as &lt;struct&gt;
         *  - "ay" is serialized as &lt;base64&gt;
         *  - Other arrays and tuples are serialized as &lt;array&gt;
         *  - booleans are serialized as &lt;boolean&gt;
         *  - byte, int16, uint16 and int32 are serialized as &lt;int&gt;
         *  - uint32 and int64 are serialized as the nonstandard &lt;i8&gt; type
         *  - doubles are serialized as &lt;double&gt;
         *  - Strings are serialized as &lt;string&gt;
         *  - Variants (i.e. "v" type) are unwrapped and their child is serialized.
         *  - #GVariants created by soup_xmlrpc_variant_new_datetime() are serialized as
         *    &lt;dateTime.iso8601&gt;
         *  - Other types are not supported and will return %NULL and set `error`.
         *    This notably includes: object-paths, signatures, uint64, handles, maybes
         *    and dictionaries with non-string keys.
         *
         * If `params` is floating, it is consumed.
         * @param method_name the name of the XML-RPC method
         * @param params a #GVariant tuple
         * @returns the text of the methodCall, or %NULL on error.
         */
        function xmlrpc_build_request(method_name: string, params: GLib.Variant): string;
        /**
         * This creates a (successful) XML-RPC methodResponse and returns it
         * as a string. To create a fault response, use soup_xmlrpc_build_fault(). This
         * is the low-level method that soup_xmlrpc_message_set_response() is built on.
         *
         * See soup_xmlrpc_build_request() for serialization details, but note
         * that since a method can only have a single return value, `value`
         * should not be a tuple here (unless the return value is an array).
         *
         * If `value` is floating, it is consumed.
         * @param value the return value
         * @returns the text of the methodResponse, or %NULL on error.
         */
        function xmlrpc_build_response(value: GLib.Variant): string;
        function xmlrpc_error_quark(): GLib.Quark;
        function xmlrpc_fault_quark(): GLib.Quark;
        /**
         * Creates an XML-RPC methodCall and returns a #SoupMessage, ready
         * to send, for that method call.
         *
         * See soup_xmlrpc_build_request() for serialization details.
         *
         * If `params` is floating, it is consumed.
         * @param uri URI of the XML-RPC service
         * @param method_name the name of the XML-RPC method to invoke at @uri
         * @param params a #GVariant tuple
         * @returns a #SoupMessage encoding the   indicated XML-RPC request, or %NULL on error.
         */
        function xmlrpc_message_new(uri: string, method_name: string, params: GLib.Variant): Message;
        /**
         * Sets the status code and response body of `msg` to indicate a
         * successful XML-RPC call, with a return value given by `value`. To set a
         * fault response, use soup_xmlrpc_message_set_fault().
         *
         * See soup_xmlrpc_build_request() for serialization details.
         *
         * If `value` is floating, it is consumed.
         * @param msg an XML-RPC request
         * @param value a #GVariant
         * @returns %TRUE on success, %FALSE otherwise.
         */
        function xmlrpc_message_set_response(msg: Message, value: GLib.Variant): boolean;
        /**
         * Parses `method_call` to get the name and parameters, and returns the
         * parameter values in a #GValueArray; see also
         * soup_xmlrpc_extract_method_call(), which is more convenient if you
         * know in advance what the types of the parameters will be.
         * @param method_call the XML-RPC methodCall string
         * @param length the length of @method_call, or -1 if it is NUL-terminated
         * @returns success or failure.
         */
        function xmlrpc_parse_method_call(method_call: string, length: number): [boolean, string, GObject.ValueArray];
        /**
         * Parses `method_response` and returns the return value in `value`. If
         * `method_response` is a fault, `value` will be unchanged, and `error`
         * will be set to an error of type %SOUP_XMLRPC_FAULT, with the error
         * #code containing the fault code, and the error #message containing
         * the fault string. (If `method_response` cannot be parsed at all,
         * soup_xmlrpc_parse_method_response() will return %FALSE, but `error`
         * will be unset.)
         * @param method_response the XML-RPC methodResponse string
         * @param length the length of @method_response, or -1 if it is NUL-terminated
         * @returns %TRUE if a return value was parsed, %FALSE if the response could not be parsed, or contained a fault.
         */
        function xmlrpc_parse_method_response(method_response: string, length: number): [boolean, unknown];
        /**
         * Parses `method_call` and return the method name. Method parameters can be
         * parsed later using soup_xmlrpc_params_parse().
         * @param method_call the XML-RPC methodCall string
         * @param length the length of @method_call, or -1 if it is NUL-terminated
         * @returns method's name, or %NULL on error.
         */
        function xmlrpc_parse_request(method_call: string, length: number): [string, XMLRPCParams];
        /**
         * Parses `method_response` and returns the return value. If
         * `method_response` is a fault, %NULL is returned, and `error`
         * will be set to an error in the %SOUP_XMLRPC_FAULT domain, with the error
         * code containing the fault code, and the error message containing
         * the fault string. If `method_response` cannot be parsed, %NULL is returned,
         * and `error` will be set to an error in the %SOUP_XMLRPC_ERROR domain.
         *
         * See soup_xmlrpc_params_parse() for deserialization details.
         * @param method_response the XML-RPC methodResponse string
         * @param length the length of @method_response, or -1 if it is NUL-terminated
         * @param signature A valid #GVariant type string, or %NULL
         * @returns a new (non-floating) #GVariant, or %NULL
         */
        function xmlrpc_parse_response(
            method_response: string,
            length: number,
            signature?: string | null,
        ): GLib.Variant;
        /**
         * Get the #SoupDate from special #GVariant created by
         * soup_xmlrpc_variant_new_datetime() or by parsing a &lt;dateTime.iso8601&gt;
         * node. See soup_xmlrpc_params_parse().
         *
         * If `variant` does not contain a datetime it will return an error but it is not
         * considered a programmer error because it generally means parameters received
         * are not in the expected type.
         * @param variant a #GVariant
         * @returns a new #SoupDate, or %NULL on error.
         */
        function xmlrpc_variant_get_datetime(variant: GLib.Variant): Date;
        /**
         * Construct a special #GVariant used to serialize a &lt;dateTime.iso8601&gt;
         * node. See soup_xmlrpc_build_request().
         *
         * The actual type of the returned #GVariant is unspecified and "v" or "*"
         * should be used in variant format strings. For example:
         * <informalexample><programlisting>
         * args = g_variant_new ("(v)", soup_xmlrpc_variant_new_datetime (date));
         * </programlisting></informalexample>
         * @param date a #SoupDate
         * @returns a floating #GVariant.
         */
        function xmlrpc_variant_new_datetime(date: Date): GLib.Variant;
        interface AddressCallback {
            (addr: Address, status: number): void;
        }
        interface AuthDomainBasicAuthCallback {
            (domain: AuthDomainBasic, msg: Message, username: string, password: string): boolean;
        }
        interface AuthDomainDigestAuthCallback {
            (domain: AuthDomainDigest, msg: Message, username: string): string | null;
        }
        interface AuthDomainFilter {
            (domain: AuthDomain, msg: Message): boolean;
        }
        interface AuthDomainGenericAuthCallback {
            (domain: AuthDomain, msg: Message, username: string): boolean;
        }
        interface ChunkAllocator {
            (msg: Message, max_len: number): Buffer | null;
        }
        interface LoggerFilter {
            (logger: Logger, msg: Message): LoggerLogLevel;
        }
        interface LoggerPrinter {
            (logger: Logger, level: LoggerLogLevel, direction: number, data: string): void;
        }
        interface MessageHeadersForeachFunc {
            (name: string, value: string): void;
        }
        interface PasswordManagerCallback {
            (password_manager: PasswordManager, msg: Message, auth: Auth, retrying: boolean): void;
        }
        interface ProxyResolverCallback {
            (proxy_resolver: ProxyResolver, msg: Message, arg: number, addr: Address): void;
        }
        interface ProxyURIResolverCallback {
            (resolver: ProxyURIResolver, status: number, proxy_uri: URI): void;
        }
        interface ServerCallback {
            (
                server: Server,
                msg: Message,
                path: string,
                query: GLib.HashTable<string, string> | null,
                client: ClientContext,
            ): void;
        }
        interface ServerWebsocketCallback {
            (server: Server, connection: WebsocketConnection, path: string, client: ClientContext): void;
        }
        interface SessionCallback {
            (session: Session, msg: Message): void;
        }
        interface SessionConnectProgressCallback {
            (session: Session, event: Gio.SocketClientEvent, connection: Gio.IOStream): void;
        }
        interface SocketCallback {
            (sock: Socket, status: number): void;
        }
        type ByteArray = object | null;

        export namespace Cacheability {
            export const $gtype: GObject.GType<Cacheability>;
        }

        enum Cacheability {
            CACHEABLE,
            UNCACHEABLE,
            INVALIDATES,
            VALIDATES,
        }
        /**
         * Represents the parsed value of the "Expect" header.
         */

        /**
         * Represents the parsed value of the "Expect" header.
         */
        export namespace Expectation {
            export const $gtype: GObject.GType<Expectation>;
        }

        enum Expectation {
            /**
             * any unrecognized expectation
             */
            UNRECOGNIZED,
            /**
             * "100-continue"
             */
            CONTINUE,
        }
        /**
         * Various flags that can be set on a #SoupMessage to alter its
         * behavior.
         */

        /**
         * Various flags that can be set on a #SoupMessage to alter its
         * behavior.
         */
        export namespace MessageFlags {
            export const $gtype: GObject.GType<MessageFlags>;
        }

        enum MessageFlags {
            /**
             * The session should not follow redirect
             *   (3xx) responses received by this message.
             */
            NO_REDIRECT,
            /**
             * The caller will rebuild the request
             *   body if the message is restarted; see
             *   soup_message_body_set_accumulate() for more details.
             */
            CAN_REBUILD,
            /**
             * Deprecated: equivalent to calling
             *   soup_message_body_set_accumulate() on the incoming message body
             *   (ie, #SoupMessage:response_body for a client-side request),
             *   passing %FALSE.
             */
            OVERWRITE_CHUNKS,
            /**
             * Set by #SoupContentDecoder to
             *   indicate that it has removed the Content-Encoding on a message (and
             *   so headers such as Content-Length may no longer accurately describe
             *   the body).
             */
            CONTENT_DECODED,
            /**
             * if set after an https response
             *   has been received, indicates that the server's SSL certificate is
             *   trusted according to the session's CA.
             */
            CERTIFICATE_TRUSTED,
            /**
             * Requests that the message should be
             *   sent on a newly-created connection, not reusing an existing
             *   persistent connection. Note that messages with non-idempotent
             *   #SoupMessage:method<!-- -->s behave this way by default, unless
             *   #SOUP_MESSAGE_IDEMPOTENT is set.
             */
            NEW_CONNECTION,
            /**
             * The message is considered idempotent,
             *   regardless its #SoupMessage:method, and allows reuse of existing
             *   idle connections, instead of always requiring a new one, unless
             *   #SOUP_MESSAGE_NEW_CONNECTION is set.
             */
            IDEMPOTENT,
            /**
             * Request that a new connection is
             *   created for the message if there aren't idle connections available
             *   and it's not possible to create new connections due to any of the
             *   connection limits has been reached. If a dedicated connection is
             *   eventually created for this message, it will be dropped when the
             *   message finishes. Since 2.50
             */
            IGNORE_CONNECTION_LIMITS,
            /**
             * The #SoupAuthManager should not use
             *   the credentials cache for this message, neither to use cached credentials
             *   to automatically authenticate this message nor to cache the credentials
             *   after the message is successfully authenticated. This applies to both server
             *   and proxy authentication. Note that #SoupSession::authenticate signal will
             *   be emitted, if you want to disable authentication for a message use
             *   soup_message_disable_feature() passing #SOUP_TYPE_AUTH_MANAGER instead. Since 2.58
             */
            DO_NOT_USE_AUTH_CACHE,
        }
        /**
         * Options to pass to soup_server_listen(), etc.
         *
         * %SOUP_SERVER_LISTEN_IPV4_ONLY and %SOUP_SERVER_LISTEN_IPV6_ONLY
         * only make sense with soup_server_listen_all() and
         * soup_server_listen_local(), not plain soup_server_listen() (which
         * simply listens on whatever kind of socket you give it). And you
         * cannot specify both of them in a single call.
         */

        /**
         * Options to pass to soup_server_listen(), etc.
         *
         * %SOUP_SERVER_LISTEN_IPV4_ONLY and %SOUP_SERVER_LISTEN_IPV6_ONLY
         * only make sense with soup_server_listen_all() and
         * soup_server_listen_local(), not plain soup_server_listen() (which
         * simply listens on whatever kind of socket you give it). And you
         * cannot specify both of them in a single call.
         */
        export namespace ServerListenOptions {
            export const $gtype: GObject.GType<ServerListenOptions>;
        }

        enum ServerListenOptions {
            /**
             * Listen for https connections rather
             *   than plain http.
             */
            HTTPS,
            /**
             * Only listen on IPv4 interfaces.
             */
            IPV4_ONLY,
            /**
             * Only listen on IPv6 interfaces.
             */
            IPV6_ONLY,
        }
        namespace Address {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                'notify::family': (pspec: GObject.ParamSpec) => void;
                'notify::name': (pspec: GObject.ParamSpec) => void;
                'notify::physical': (pspec: GObject.ParamSpec) => void;
                'notify::port': (pspec: GObject.ParamSpec) => void;
                'notify::protocol': (pspec: GObject.ParamSpec) => void;
                'notify::sockaddr': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, Gio.SocketConnectable.ConstructorProps {
                family: AddressFamily;
                name: string;
                physical: string;
                port: number;
                protocol: string;
                sockaddr: any;
            }
        }

        class Address extends GObject.Object implements Gio.SocketConnectable {
            static $gtype: GObject.GType<Address>;

            // Properties

            get family(): AddressFamily;
            get name(): string;
            get physical(): string;
            get port(): number;
            get protocol(): string;
            get sockaddr(): any;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: Address.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<Address.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](name: string, port: number): Address;

            static new_any(family: AddressFamily, port: number): Address;

            static new_from_sockaddr(sa: any | null, len: number): Address;

            // Signals

            connect<K extends keyof Address.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Address.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof Address.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Address.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof Address.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<Address.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Methods

            /**
             * Tests if `addr1` and `addr2` have the same IP address. This method
             * can be used with soup_address_hash_by_ip() to create a
             * #GHashTable that hashes on IP address.
             *
             * This would be used to distinguish hosts in situations where
             * different virtual hosts on the same IP address should be considered
             * the same. Eg, if "www.example.com" and "www.example.net" have the
             * same IP address, then a single connection can be used to talk
             * to either of them.
             *
             * See also soup_address_equal_by_name(), which compares by name
             * rather than by IP address.
             * @param addr2 another #SoupAddress with a resolved   IP address
             * @returns whether or not @addr1 and @addr2 have the same IP address.
             */
            equal_by_ip(addr2: Address): boolean;
            /**
             * Tests if `addr1` and `addr2` have the same "name". This method can be
             * used with soup_address_hash_by_name() to create a #GHashTable that
             * hashes on address "names".
             *
             * Comparing by name normally means comparing the addresses by their
             * hostnames. But if the address was originally created using an IP
             * address literal, then it will be compared by that instead.
             *
             * In particular, if "www.example.com" has the IP address 10.0.0.1,
             * and `addr1` was created with the name "www.example.com" and `addr2`
             * was created with the name "10.0.0.1", then they will compare as
             * unequal for purposes of soup_address_equal_by_name().
             *
             * This would be used to distinguish hosts in situations where
             * different virtual hosts on the same IP address should be considered
             * different. Eg, for purposes of HTTP authentication or cookies, two
             * hosts with the same IP address but different names are considered
             * to be different hosts.
             *
             * See also soup_address_equal_by_ip(), which compares by IP address
             * rather than by name.
             * @param addr2 another #SoupAddress with a resolved   name
             * @returns whether or not @addr1 and @addr2 have the same name
             */
            equal_by_name(addr2: Address): boolean;
            /**
             * Creates a new #GSocketAddress corresponding to `addr` (which is assumed
             * to only have one socket address associated with it).
             * @returns a new #GSocketAddress
             */
            get_gsockaddr(): Gio.SocketAddress;
            /**
             * Returns the hostname associated with `addr`.
             *
             * This method is not thread-safe; if you call it while `addr` is being
             * resolved in another thread, it may return garbage. You can use
             * soup_address_is_resolved() to safely test whether or not an address
             * is resolved before fetching its name or address.
             * @returns the hostname, or %NULL if it is not known.
             */
            get_name(): string | null;
            /**
             * Returns the physical address associated with `addr` as a string.
             * (Eg, "127.0.0.1"). If the address is not yet known, returns %NULL.
             *
             * This method is not thread-safe; if you call it while `addr` is being
             * resolved in another thread, it may return garbage. You can use
             * soup_address_is_resolved() to safely test whether or not an address
             * is resolved before fetching its name or address.
             * @returns the physical address, or %NULL
             */
            get_physical(): string | null;
            /**
             * Returns the port associated with `addr`.
             * @returns the port
             */
            get_port(): number;
            /**
             * Returns the sockaddr associated with `addr,` with its length in
             * *`len`. If the sockaddr is not yet known, returns %NULL.
             *
             * This method is not thread-safe; if you call it while `addr` is being
             * resolved in another thread, it may return garbage. You can use
             * soup_address_is_resolved() to safely test whether or not an address
             * is resolved before fetching its name or address.
             * @returns the sockaddr, or %NULL
             */
            get_sockaddr(): [any | null, number];
            /**
             * A hash function (for #GHashTable) that corresponds to
             * soup_address_equal_by_ip(), qv
             * @returns the IP-based hash value for @addr.
             */
            hash_by_ip(): number;
            /**
             * A hash function (for #GHashTable) that corresponds to
             * soup_address_equal_by_name(), qv
             * @returns the named-based hash value for @addr.
             */
            hash_by_name(): number;
            /**
             * Tests if `addr` has already been resolved. Unlike the other
             * #SoupAddress "get" methods, this is safe to call when `addr` might
             * be being resolved in another thread.
             * @returns %TRUE if @addr has been resolved.
             */
            is_resolved(): boolean;
            /**
             * Asynchronously resolves the missing half of `addr` (its IP address
             * if it was created with soup_address_new(), or its hostname if it
             * was created with soup_address_new_from_sockaddr() or
             * soup_address_new_any().)
             *
             * If `cancellable` is non-%NULL, it can be used to cancel the
             * resolution. `callback` will still be invoked in this case, with a
             * status of %SOUP_STATUS_CANCELLED.
             *
             * It is safe to call this more than once on a given address, from the
             * same thread, with the same `async_context` (and doing so will not
             * result in redundant DNS queries being made). But it is not safe to
             * call from multiple threads, or with different `async_contexts,` or
             * mixed with calls to soup_address_resolve_sync().
             * @param async_context the #GMainContext to call @callback from
             * @param cancellable a #GCancellable object, or %NULL
             * @param callback callback to call with the result
             */
            resolve_async(
                async_context: GLib.MainContext | null,
                cancellable: Gio.Cancellable | null,
                callback: AddressCallback,
            ): void;
            /**
             * Synchronously resolves the missing half of `addr,` as with
             * soup_address_resolve_async().
             *
             * If `cancellable` is non-%NULL, it can be used to cancel the
             * resolution. soup_address_resolve_sync() will then return a status
             * of %SOUP_STATUS_CANCELLED.
             *
             * It is safe to call this more than once, even from different
             * threads, but it is not safe to mix calls to
             * soup_address_resolve_sync() with calls to
             * soup_address_resolve_async() on the same address.
             * @param cancellable a #GCancellable object, or %NULL
             * @returns %SOUP_STATUS_OK, %SOUP_STATUS_CANT_RESOLVE, or %SOUP_STATUS_CANCELLED.
             */
            resolve_sync(cancellable?: Gio.Cancellable | null): number;

            // Inherited methods
            /**
             * Creates a #GSocketAddressEnumerator for `connectable`.
             * @returns a new #GSocketAddressEnumerator.
             */
            enumerate(): Gio.SocketAddressEnumerator;
            /**
             * Creates a #GSocketAddressEnumerator for `connectable` that will
             * return a #GProxyAddress for each of its addresses that you must connect
             * to via a proxy.
             *
             * If `connectable` does not implement
             * g_socket_connectable_proxy_enumerate(), this will fall back to
             * calling g_socket_connectable_enumerate().
             * @returns a new #GSocketAddressEnumerator.
             */
            proxy_enumerate(): Gio.SocketAddressEnumerator;
            /**
             * Format a #GSocketConnectable as a string. This is a human-readable format for
             * use in debugging output, and is not a stable serialization format. It is not
             * suitable for use in user interfaces as it exposes too much information for a
             * user.
             *
             * If the #GSocketConnectable implementation does not support string formatting,
             * the implementation’s type name will be returned as a fallback.
             * @returns the formatted string
             */
            to_string(): string;
            /**
             * Creates a #GSocketAddressEnumerator for `connectable`.
             */
            vfunc_enumerate(): Gio.SocketAddressEnumerator;
            /**
             * Creates a #GSocketAddressEnumerator for `connectable` that will
             * return a #GProxyAddress for each of its addresses that you must connect
             * to via a proxy.
             *
             * If `connectable` does not implement
             * g_socket_connectable_proxy_enumerate(), this will fall back to
             * calling g_socket_connectable_enumerate().
             */
            vfunc_proxy_enumerate(): Gio.SocketAddressEnumerator;
            /**
             * Format a #GSocketConnectable as a string. This is a human-readable format for
             * use in debugging output, and is not a stable serialization format. It is not
             * suitable for use in user interfaces as it exposes too much information for a
             * user.
             *
             * If the #GSocketConnectable implementation does not support string formatting,
             * the implementation’s type name will be returned as a fallback.
             */
            vfunc_to_string(): string;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Auth {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                'notify::host': (pspec: GObject.ParamSpec) => void;
                'notify::is-authenticated': (pspec: GObject.ParamSpec) => void;
                'notify::is-for-proxy': (pspec: GObject.ParamSpec) => void;
                'notify::realm': (pspec: GObject.ParamSpec) => void;
                'notify::scheme-name': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                host: string;
                is_authenticated: boolean;
                isAuthenticated: boolean;
                is_for_proxy: boolean;
                isForProxy: boolean;
                realm: string;
                scheme_name: string;
                schemeName: string;
            }
        }

        /**
         * The abstract base class for handling authentication. Specific HTTP
         * Authentication mechanisms are implemented by its subclasses, but
         * applications never need to be aware of the specific subclasses
         * being used.
         */
        abstract class Auth extends GObject.Object {
            static $gtype: GObject.GType<Auth>;

            // Properties

            get host(): string;
            set host(val: string);
            get is_authenticated(): boolean;
            get isAuthenticated(): boolean;
            get is_for_proxy(): boolean;
            set is_for_proxy(val: boolean);
            get isForProxy(): boolean;
            set isForProxy(val: boolean);
            get realm(): string;
            set realm(val: string);
            get scheme_name(): string;
            get schemeName(): string;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: Auth.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<Auth.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](type: GObject.GType, msg: Message, auth_header: string): Auth;

            // Signals

            connect<K extends keyof Auth.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Auth.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof Auth.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Auth.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof Auth.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<Auth.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            /**
             * Call this on an auth to authenticate it; normally this will cause
             * the auth's message to be requeued with the new authentication info.
             * @param username the username provided by the user or client
             * @param password the password provided by the user or client
             */
            vfunc_authenticate(username: string, password: string): void;
            /**
             * Tests if `auth` is able to authenticate by providing credentials to the
             * soup_auth_authenticate().
             */
            vfunc_can_authenticate(): boolean;
            /**
             * Generates an appropriate "Authorization" header for `msg`. (The
             * session will only call this if soup_auth_is_authenticated()
             * returned %TRUE.)
             * @param msg the #SoupMessage to be authorized
             */
            vfunc_get_authorization(msg: Message): string;
            /**
             * Returns a list of paths on the server which `auth` extends over.
             * (All subdirectories of these paths are also assumed to be part
             * of `auth'`s protection space, unless otherwise discovered not to
             * be.)
             * @param source_uri the URI of the request that @auth was generated in response to.
             */
            vfunc_get_protection_space(source_uri: URI): string[];
            /**
             * Tests if `auth` has been given a username and password
             */
            vfunc_is_authenticated(): boolean;
            /**
             * Tests if `auth` is ready to make a request for `msg` with. For most
             * auths, this is equivalent to soup_auth_is_authenticated(), but for
             * some auth types (eg, NTLM), the auth may be sendable (eg, as an
             * authentication request) even before it is authenticated.
             * @param msg a #SoupMessage
             */
            vfunc_is_ready(msg: Message): boolean;
            /**
             * Updates `auth` with the information from `msg` and `auth_header,`
             * possibly un-authenticating it. As with soup_auth_new(), this is
             * normally only used by #SoupSession.
             * @param msg the #SoupMessage @auth is being updated for
             * @param auth_header the WWW-Authenticate/Proxy-Authenticate header
             */
            vfunc_update(msg: Message, auth_header: { [key: string]: any } | GLib.HashTable<any, any>): boolean;

            // Methods

            /**
             * Call this on an auth to authenticate it; normally this will cause
             * the auth's message to be requeued with the new authentication info.
             * @param username the username provided by the user or client
             * @param password the password provided by the user or client
             */
            authenticate(username: string, password: string): void;
            /**
             * Tests if `auth` is able to authenticate by providing credentials to the
             * soup_auth_authenticate().
             * @returns %TRUE if @auth is able to accept credentials.
             */
            can_authenticate(): boolean;
            /**
             * Generates an appropriate "Authorization" header for `msg`. (The
             * session will only call this if soup_auth_is_authenticated()
             * returned %TRUE.)
             * @param msg the #SoupMessage to be authorized
             * @returns the "Authorization" header, which must be freed.
             */
            get_authorization(msg: Message): string;
            /**
             * Returns the host that `auth` is associated with.
             * @returns the hostname
             */
            get_host(): string;
            /**
             * Gets an opaque identifier for `auth,` for use as a hash key or the
             * like. #SoupAuth objects from the same server with the same
             * identifier refer to the same authentication domain (eg, the URLs
             * associated with them take the same usernames and passwords).
             * @returns the identifier
             */
            get_info(): string;
            /**
             * Returns a list of paths on the server which `auth` extends over.
             * (All subdirectories of these paths are also assumed to be part
             * of `auth'`s protection space, unless otherwise discovered not to
             * be.)
             * @param source_uri the URI of the request that @auth was generated in response to.
             * @returns the list of paths, which can be freed with soup_auth_free_protection_space().
             */
            get_protection_space(source_uri: URI): string[];
            /**
             * Returns `auth'`s realm. This is an identifier that distinguishes
             * separate authentication spaces on a given server, and may be some
             * string that is meaningful to the user. (Although it is probably not
             * localized.)
             * @returns the realm name
             */
            get_realm(): string;
            get_saved_password(user: string): string;
            get_saved_users(): string[];
            /**
             * Returns `auth'`s scheme name. (Eg, "Basic", "Digest", or "NTLM")
             * @returns the scheme name
             */
            get_scheme_name(): string;
            has_saved_password(username: string, password: string): void;
            /**
             * Tests if `auth` is ready to make a request for `msg` with. For most
             * auths, this is equivalent to soup_auth_is_authenticated(), but for
             * some auth types (eg, NTLM), the auth may be sendable (eg, as an
             * authentication request) even before it is authenticated.
             * @param msg a #SoupMessage
             * @returns %TRUE if @auth is ready to make a request with.
             */
            is_ready(msg: Message): boolean;
            save_password(username: string, password: string): void;
            /**
             * Updates `auth` with the information from `msg` and `auth_header,`
             * possibly un-authenticating it. As with soup_auth_new(), this is
             * normally only used by #SoupSession.
             * @param msg the #SoupMessage @auth is being updated for
             * @param auth_header the WWW-Authenticate/Proxy-Authenticate header
             * @returns %TRUE if @auth is still a valid (but potentially unauthenticated) #SoupAuth. %FALSE if something about @auth_params could not be parsed or incorporated into @auth at all.
             */
            update(msg: Message, auth_header: string): boolean;
        }

        namespace AuthBasic {
            // Signal signatures
            interface SignalSignatures extends Auth.SignalSignatures {
                'notify::host': (pspec: GObject.ParamSpec) => void;
                'notify::is-authenticated': (pspec: GObject.ParamSpec) => void;
                'notify::is-for-proxy': (pspec: GObject.ParamSpec) => void;
                'notify::realm': (pspec: GObject.ParamSpec) => void;
                'notify::scheme-name': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends Auth.ConstructorProps {}
        }

        class AuthBasic extends Auth {
            static $gtype: GObject.GType<AuthBasic>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: AuthBasic.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<AuthBasic.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof AuthBasic.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthBasic.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof AuthBasic.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthBasic.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof AuthBasic.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<AuthBasic.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;
        }

        namespace AuthDigest {
            // Signal signatures
            interface SignalSignatures extends Auth.SignalSignatures {
                'notify::host': (pspec: GObject.ParamSpec) => void;
                'notify::is-authenticated': (pspec: GObject.ParamSpec) => void;
                'notify::is-for-proxy': (pspec: GObject.ParamSpec) => void;
                'notify::realm': (pspec: GObject.ParamSpec) => void;
                'notify::scheme-name': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends Auth.ConstructorProps {}
        }

        class AuthDigest extends Auth {
            static $gtype: GObject.GType<AuthDigest>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: AuthDigest.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<AuthDigest.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof AuthDigest.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthDigest.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof AuthDigest.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthDigest.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof AuthDigest.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<AuthDigest.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;
        }

        namespace AuthDomain {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                'notify::add-path': (pspec: GObject.ParamSpec) => void;
                'notify::filter': (pspec: GObject.ParamSpec) => void;
                'notify::filter-data': (pspec: GObject.ParamSpec) => void;
                'notify::generic-auth-callback': (pspec: GObject.ParamSpec) => void;
                'notify::generic-auth-data': (pspec: GObject.ParamSpec) => void;
                'notify::proxy': (pspec: GObject.ParamSpec) => void;
                'notify::realm': (pspec: GObject.ParamSpec) => void;
                'notify::remove-path': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                add_path: string;
                addPath: string;
                filter: AuthDomainFilter;
                filter_data: any;
                filterData: any;
                generic_auth_callback: AuthDomainGenericAuthCallback;
                genericAuthCallback: AuthDomainGenericAuthCallback;
                generic_auth_data: any;
                genericAuthData: any;
                proxy: boolean;
                realm: string;
                remove_path: string;
                removePath: string;
            }
        }

        abstract class AuthDomain extends GObject.Object {
            static $gtype: GObject.GType<AuthDomain>;

            // Properties

            set add_path(val: string);
            set addPath(val: string);
            /**
             * The #SoupAuthDomainFilter for the domain
             */
            get filter(): AuthDomainFilter;
            set filter(val: AuthDomainFilter);
            get filter_data(): any;
            set filter_data(val: any);
            get filterData(): any;
            set filterData(val: any);
            /**
             * The #SoupAuthDomainGenericAuthCallback for the domain
             */
            get generic_auth_callback(): AuthDomainGenericAuthCallback;
            set generic_auth_callback(val: AuthDomainGenericAuthCallback);
            /**
             * The #SoupAuthDomainGenericAuthCallback for the domain
             */
            get genericAuthCallback(): AuthDomainGenericAuthCallback;
            set genericAuthCallback(val: AuthDomainGenericAuthCallback);
            get generic_auth_data(): any;
            set generic_auth_data(val: any);
            get genericAuthData(): any;
            set genericAuthData(val: any);
            get proxy(): boolean;
            get realm(): string;
            set remove_path(val: string);
            set removePath(val: string);

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: AuthDomain.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<AuthDomain.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof AuthDomain.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthDomain.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof AuthDomain.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthDomain.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof AuthDomain.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<AuthDomain.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            vfunc_accepts(msg: Message, header: string): string;
            /**
             * Adds a "WWW-Authenticate" or "Proxy-Authenticate" header to `msg,`
             * requesting that the client authenticate, and sets `msg'`s status
             * accordingly.
             *
             * This is used by #SoupServer internally and is probably of no use to
             * anyone else.
             * @param msg a #SoupMessage
             */
            vfunc_challenge(msg: Message): string;
            /**
             * Checks if `msg` authenticates to `domain` via `username` and
             * `password`. This would normally be called from a
             * #SoupAuthDomainGenericAuthCallback.
             * @param msg a #SoupMessage
             * @param username a username
             * @param password a password
             */
            vfunc_check_password(msg: Message, username: string, password: string): boolean;

            // Methods

            /**
             * Checks if `msg` contains appropriate authorization for `domain` to
             * accept it. Mirroring soup_auth_domain_covers(), this does not check
             * whether or not `domain` <emphasis>cares</emphasis> if `msg` is
             * authorized.
             *
             * This is used by #SoupServer internally and is probably of no use to
             * anyone else.
             * @param msg a #SoupMessage
             * @returns the username that @msg has authenticated as, if in fact it has authenticated. %NULL otherwise.
             */
            accepts(msg: Message): string | null;
            /**
             * Adds a "WWW-Authenticate" or "Proxy-Authenticate" header to `msg,`
             * requesting that the client authenticate, and sets `msg'`s status
             * accordingly.
             *
             * This is used by #SoupServer internally and is probably of no use to
             * anyone else.
             * @param msg a #SoupMessage
             */
            challenge(msg: Message): void;
            /**
             * Checks if `msg` authenticates to `domain` via `username` and
             * `password`. This would normally be called from a
             * #SoupAuthDomainGenericAuthCallback.
             * @param msg a #SoupMessage
             * @param username a username
             * @param password a password
             * @returns whether or not the message is authenticated
             */
            check_password(msg: Message, username: string, password: string): boolean;
            /**
             * Checks if `domain` requires `msg` to be authenticated (according to
             * its paths and filter function). This does not actually look at
             * whether `msg` <emphasis>is</emphasis> authenticated, merely whether
             * or not it needs to be.
             *
             * This is used by #SoupServer internally and is probably of no use to
             * anyone else.
             * @param msg a #SoupMessage
             * @returns %TRUE if @domain requires @msg to be authenticated
             */
            covers(msg: Message): boolean;
            /**
             * Gets the realm name associated with `domain`
             * @returns @domain's realm
             */
            get_realm(): string;
            /**
             * Adds `filter` as an authentication filter to `domain`. The filter
             * gets a chance to bypass authentication for certain requests that
             * would otherwise require it. Eg, it might check the message's path
             * in some way that is too complicated to do via the other methods, or
             * it might check the message's method, and allow GETs but not PUTs.
             *
             * The filter function returns %TRUE if the request should still
             * require authentication, or %FALSE if authentication is unnecessary
             * for this request.
             *
             * To help prevent security holes, your filter should return %TRUE by
             * default, and only return %FALSE under specifically-tested
             * circumstances, rather than the other way around. Eg, in the example
             * above, where you want to authenticate PUTs but not GETs, you should
             * check if the method is GET and return %FALSE in that case, and then
             * return %TRUE for all other methods (rather than returning %TRUE for
             * PUT and %FALSE for all other methods). This way if it turned out
             * (now or later) that some paths supported additional methods besides
             * GET and PUT, those methods would default to being NOT allowed for
             * unauthenticated users.
             *
             * You can also set the filter by setting the %SOUP_AUTH_DOMAIN_FILTER
             * and %SOUP_AUTH_DOMAIN_FILTER_DATA properties, which can also be
             * used to set the filter at construct time.
             * @param filter the auth filter for @domain
             */
            set_filter(filter: AuthDomainFilter): void;
            /**
             * Sets `auth_callback` as an authentication-handling callback for
             * `domain`. Whenever a request comes in to `domain` which cannot be
             * authenticated via a domain-specific auth callback (eg,
             * #SoupAuthDomainDigestAuthCallback), the generic auth callback
             * will be invoked. See #SoupAuthDomainGenericAuthCallback for information
             * on what the callback should do.
             * @param auth_callback the auth callback
             */
            set_generic_auth_callback(auth_callback: AuthDomainGenericAuthCallback): void;
            try_generic_auth_callback(msg: Message, username: string): boolean;
        }

        namespace AuthDomainBasic {
            // Signal signatures
            interface SignalSignatures extends AuthDomain.SignalSignatures {
                'notify::auth-callback': (pspec: GObject.ParamSpec) => void;
                'notify::auth-data': (pspec: GObject.ParamSpec) => void;
                'notify::add-path': (pspec: GObject.ParamSpec) => void;
                'notify::filter': (pspec: GObject.ParamSpec) => void;
                'notify::filter-data': (pspec: GObject.ParamSpec) => void;
                'notify::generic-auth-callback': (pspec: GObject.ParamSpec) => void;
                'notify::generic-auth-data': (pspec: GObject.ParamSpec) => void;
                'notify::proxy': (pspec: GObject.ParamSpec) => void;
                'notify::realm': (pspec: GObject.ParamSpec) => void;
                'notify::remove-path': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends AuthDomain.ConstructorProps {
                auth_callback: AuthDomainBasicAuthCallback;
                authCallback: AuthDomainBasicAuthCallback;
                auth_data: any;
                authData: any;
            }
        }

        class AuthDomainBasic extends AuthDomain {
            static $gtype: GObject.GType<AuthDomainBasic>;

            // Properties

            /**
             * The #SoupAuthDomainBasicAuthCallback
             */
            get auth_callback(): AuthDomainBasicAuthCallback;
            set auth_callback(val: AuthDomainBasicAuthCallback);
            /**
             * The #SoupAuthDomainBasicAuthCallback
             */
            get authCallback(): AuthDomainBasicAuthCallback;
            set authCallback(val: AuthDomainBasicAuthCallback);
            /**
             * The data to pass to the #SoupAuthDomainBasicAuthCallback
             */
            get auth_data(): any;
            set auth_data(val: any);
            /**
             * The data to pass to the #SoupAuthDomainBasicAuthCallback
             */
            get authData(): any;
            set authData(val: any);

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: AuthDomainBasic.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<AuthDomainBasic.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof AuthDomainBasic.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthDomainBasic.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof AuthDomainBasic.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthDomainBasic.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof AuthDomainBasic.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<AuthDomainBasic.SignalSignatures[K]> extends [any, ...infer Q]
                    ? Q
                    : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Methods

            /**
             * Sets the callback that `domain` will use to authenticate incoming
             * requests. For each request containing authorization, `domain` will
             * invoke the callback, and then either accept or reject the request
             * based on `callback'`s return value.
             *
             * You can also set the auth callback by setting the
             * %SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK and
             * %SOUP_AUTH_DOMAIN_BASIC_AUTH_DATA properties, which can also be
             * used to set the callback at construct time.
             * @param callback the callback
             */
            set_auth_callback(callback: AuthDomainBasicAuthCallback): void;
        }

        namespace AuthDomainDigest {
            // Signal signatures
            interface SignalSignatures extends AuthDomain.SignalSignatures {
                'notify::auth-callback': (pspec: GObject.ParamSpec) => void;
                'notify::auth-data': (pspec: GObject.ParamSpec) => void;
                'notify::add-path': (pspec: GObject.ParamSpec) => void;
                'notify::filter': (pspec: GObject.ParamSpec) => void;
                'notify::filter-data': (pspec: GObject.ParamSpec) => void;
                'notify::generic-auth-callback': (pspec: GObject.ParamSpec) => void;
                'notify::generic-auth-data': (pspec: GObject.ParamSpec) => void;
                'notify::proxy': (pspec: GObject.ParamSpec) => void;
                'notify::realm': (pspec: GObject.ParamSpec) => void;
                'notify::remove-path': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends AuthDomain.ConstructorProps {
                auth_callback: AuthDomainDigestAuthCallback;
                authCallback: AuthDomainDigestAuthCallback;
                auth_data: any;
                authData: any;
            }
        }

        class AuthDomainDigest extends AuthDomain {
            static $gtype: GObject.GType<AuthDomainDigest>;

            // Properties

            /**
             * The #SoupAuthDomainDigestAuthCallback
             */
            get auth_callback(): AuthDomainDigestAuthCallback;
            set auth_callback(val: AuthDomainDigestAuthCallback);
            /**
             * The #SoupAuthDomainDigestAuthCallback
             */
            get authCallback(): AuthDomainDigestAuthCallback;
            set authCallback(val: AuthDomainDigestAuthCallback);
            /**
             * The data to pass to the #SoupAuthDomainDigestAuthCallback
             */
            get auth_data(): any;
            set auth_data(val: any);
            /**
             * The data to pass to the #SoupAuthDomainDigestAuthCallback
             */
            get authData(): any;
            set authData(val: any);

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: AuthDomainDigest.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<AuthDomainDigest.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof AuthDomainDigest.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthDomainDigest.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof AuthDomainDigest.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthDomainDigest.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof AuthDomainDigest.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<AuthDomainDigest.SignalSignatures[K]> extends [any, ...infer Q]
                    ? Q
                    : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Static methods

            /**
             * Encodes the username/realm/password triplet for Digest
             * authentication. (That is, it returns a stringified MD5 hash of
             * `username,` `realm,` and `password` concatenated together). This is
             * the form that is needed as the return value of
             * #SoupAuthDomainDigest's auth handler.
             *
             * For security reasons, you should store the encoded hash, rather
             * than storing the cleartext password itself and calling this method
             * only when you need to verify it. This way, if your server is
             * compromised, the attackers will not gain access to cleartext
             * passwords which might also be usable at other sites. (Note also
             * that the encoded password returned by this method is identical to
             * the encoded password stored in an Apache .htdigest file.)
             * @param username a username
             * @param realm an auth realm name
             * @param password the password for @username in @realm
             */
            static encode_password(username: string, realm: string, password: string): string;

            // Methods

            /**
             * Sets the callback that `domain` will use to authenticate incoming
             * requests. For each request containing authorization, `domain` will
             * invoke the callback, and then either accept or reject the request
             * based on `callback'`s return value.
             *
             * You can also set the auth callback by setting the
             * %SOUP_AUTH_DOMAIN_DIGEST_AUTH_CALLBACK and
             * %SOUP_AUTH_DOMAIN_DIGEST_AUTH_DATA properties, which can also be
             * used to set the callback at construct time.
             * @param callback the callback
             */
            set_auth_callback(callback: AuthDomainDigestAuthCallback): void;
        }

        namespace AuthManager {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                authenticate: (arg0: Message, arg1: Auth, arg2: boolean) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, SessionFeature.ConstructorProps {}
        }

        class AuthManager extends GObject.Object implements SessionFeature {
            static $gtype: GObject.GType<AuthManager>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: AuthManager.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<AuthManager.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof AuthManager.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthManager.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof AuthManager.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthManager.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof AuthManager.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<AuthManager.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            vfunc_authenticate(msg: Message, auth: Auth, retrying: boolean): void;

            // Methods

            /**
             * Clear all credentials cached by `manager`
             */
            clear_cached_credentials(): void;
            /**
             * Records that `auth` is to be used under `uri,` as though a
             * WWW-Authenticate header had been received at that URI. This can be
             * used to "preload" `manager'`s auth cache, to avoid an extra HTTP
             * round trip in the case where you know ahead of time that a 401
             * response will be returned.
             *
             * This is only useful for authentication types where the initial
             * Authorization header does not depend on any additional information
             * from the server. (Eg, Basic or NTLM, but not Digest.)
             * @param uri the #SoupURI under which @auth is to be used
             * @param auth the #SoupAuth to use
             */
            use_auth(uri: URI, auth: Auth): void;

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace AuthNTLM {
            // Signal signatures
            interface SignalSignatures extends Auth.SignalSignatures {
                'notify::host': (pspec: GObject.ParamSpec) => void;
                'notify::is-authenticated': (pspec: GObject.ParamSpec) => void;
                'notify::is-for-proxy': (pspec: GObject.ParamSpec) => void;
                'notify::realm': (pspec: GObject.ParamSpec) => void;
                'notify::scheme-name': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends Auth.ConstructorProps {}
        }

        class AuthNTLM extends Auth {
            static $gtype: GObject.GType<AuthNTLM>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: AuthNTLM.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<AuthNTLM.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof AuthNTLM.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthNTLM.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof AuthNTLM.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthNTLM.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof AuthNTLM.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<AuthNTLM.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;
        }

        namespace AuthNegotiate {
            // Signal signatures
            interface SignalSignatures extends Auth.SignalSignatures {
                'notify::host': (pspec: GObject.ParamSpec) => void;
                'notify::is-authenticated': (pspec: GObject.ParamSpec) => void;
                'notify::is-for-proxy': (pspec: GObject.ParamSpec) => void;
                'notify::realm': (pspec: GObject.ParamSpec) => void;
                'notify::scheme-name': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends Auth.ConstructorProps {}
        }

        class AuthNegotiate extends Auth {
            static $gtype: GObject.GType<AuthNegotiate>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: AuthNegotiate.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<AuthNegotiate.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof AuthNegotiate.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthNegotiate.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof AuthNegotiate.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, AuthNegotiate.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof AuthNegotiate.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<AuthNegotiate.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Static methods

            /**
             * Indicates whether libsoup was built with GSSAPI support. If this is
             * %FALSE, %SOUP_TYPE_AUTH_NEGOTIATE will still be defined and can
             * still be added to a #SoupSession, but libsoup will never attempt to
             * actually use this auth type.
             */
            static supported(): boolean;
        }

        namespace Cache {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                'notify::cache-dir': (pspec: GObject.ParamSpec) => void;
                'notify::cache-type': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, SessionFeature.ConstructorProps {
                cache_dir: string;
                cacheDir: string;
                cache_type: CacheType;
                cacheType: CacheType;
            }
        }

        class Cache extends GObject.Object implements SessionFeature {
            static $gtype: GObject.GType<Cache>;

            // Properties

            get cache_dir(): string;
            get cacheDir(): string;
            get cache_type(): CacheType;
            get cacheType(): CacheType;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: Cache.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<Cache.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](cache_dir: string | null, cache_type: CacheType): Cache;

            // Signals

            connect<K extends keyof Cache.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Cache.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof Cache.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Cache.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof Cache.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<Cache.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            vfunc_get_cacheability(msg: Message): Cacheability;

            // Methods

            /**
             * Will remove all entries in the `cache` plus all the cache files.
             */
            clear(): void;
            /**
             * Synchronously writes the cache index out to disk. Contrast with
             * soup_cache_flush(), which writes pending cache
             * <emphasis>entries</emphasis> to disk.
             *
             * You must call this before exiting if you want your cache data to
             * persist between sessions.
             */
            dump(): void;
            /**
             * This function will force all pending writes in the `cache` to be
             * committed to disk. For doing so it will iterate the #GMainContext
             * associated with `cache'`s session as long as needed.
             *
             * Contrast with soup_cache_dump(), which writes out the cache index
             * file.
             */
            flush(): void;
            /**
             * Gets the maximum size of the cache.
             * @returns the maximum size of the cache, in bytes.
             */
            get_max_size(): number;
            /**
             * Loads the contents of `cache'`s index into memory.
             */
            load(): void;
            /**
             * Sets the maximum size of the cache.
             * @param max_size the maximum size of the cache, in bytes
             */
            set_max_size(max_size: number): void;

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ContentDecoder {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {}

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, SessionFeature.ConstructorProps {}
        }

        class ContentDecoder extends GObject.Object implements SessionFeature {
            static $gtype: GObject.GType<ContentDecoder>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: ContentDecoder.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<ContentDecoder.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof ContentDecoder.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, ContentDecoder.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof ContentDecoder.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, ContentDecoder.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof ContentDecoder.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<ContentDecoder.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ContentSniffer {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {}

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, SessionFeature.ConstructorProps {}
        }

        class ContentSniffer extends GObject.Object implements SessionFeature {
            static $gtype: GObject.GType<ContentSniffer>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: ContentSniffer.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<ContentSniffer.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): ContentSniffer;

            // Signals

            connect<K extends keyof ContentSniffer.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, ContentSniffer.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof ContentSniffer.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, ContentSniffer.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof ContentSniffer.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<ContentSniffer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            /**
             * Gets the number of bytes `sniffer` needs in order to properly sniff
             * a buffer.
             */
            vfunc_get_buffer_size(): number;
            /**
             * Sniffs `buffer` to determine its Content-Type. The result may also
             * be influenced by the Content-Type declared in `msg'`s response
             * headers.
             * @param msg the message to sniff
             * @param buffer a buffer containing the start of @msg's response body
             */
            vfunc_sniff(msg: Message, buffer: Buffer): [string, GLib.HashTable<string, string> | null];

            // Methods

            /**
             * Gets the number of bytes `sniffer` needs in order to properly sniff
             * a buffer.
             * @returns the number of bytes to sniff
             */
            get_buffer_size(): number;
            /**
             * Sniffs `buffer` to determine its Content-Type. The result may also
             * be influenced by the Content-Type declared in `msg'`s response
             * headers.
             * @param msg the message to sniff
             * @param buffer a buffer containing the start of @msg's response body
             * @returns the sniffed Content-Type of @buffer; this will never be %NULL,   but may be "application/octet-stream".
             */
            sniff(msg: Message, buffer: Buffer): [string, GLib.HashTable<string, string> | null];

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace CookieJar {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                changed: (arg0: Cookie, arg1: Cookie) => void;
                'notify::accept-policy': (pspec: GObject.ParamSpec) => void;
                'notify::read-only': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, SessionFeature.ConstructorProps {
                accept_policy: CookieJarAcceptPolicy;
                acceptPolicy: CookieJarAcceptPolicy;
                read_only: boolean;
                readOnly: boolean;
            }
        }

        class CookieJar extends GObject.Object implements SessionFeature {
            static $gtype: GObject.GType<CookieJar>;

            // Properties

            /**
             * The policy the jar should follow to accept or reject cookies
             */
            get accept_policy(): CookieJarAcceptPolicy;
            set accept_policy(val: CookieJarAcceptPolicy);
            /**
             * The policy the jar should follow to accept or reject cookies
             */
            get acceptPolicy(): CookieJarAcceptPolicy;
            set acceptPolicy(val: CookieJarAcceptPolicy);
            get read_only(): boolean;
            get readOnly(): boolean;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: CookieJar.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<CookieJar.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): CookieJar;

            // Signals

            connect<K extends keyof CookieJar.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, CookieJar.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof CookieJar.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, CookieJar.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof CookieJar.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<CookieJar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            vfunc_changed(old_cookie: Cookie, new_cookie: Cookie): void;
            /**
             * Gets whether `jar` stores cookies persistenly.
             */
            vfunc_is_persistent(): boolean;
            /**
             * This function exists for backward compatibility, but does not do
             * anything any more; cookie jars are saved automatically when they
             * are changed.
             */
            vfunc_save(): void;

            // Methods

            /**
             * Adds `cookie` to `jar,` emitting the 'changed' signal if we are modifying
             * an existing cookie or adding a valid new cookie ('valid' means
             * that the cookie's expire date is not in the past).
             *
             * `cookie` will be 'stolen' by the jar, so don't free it afterwards.
             * @param cookie a #SoupCookie
             */
            add_cookie(cookie: Cookie): void;
            /**
             * Adds `cookie` to `jar,` emitting the 'changed' signal if we are modifying
             * an existing cookie or adding a valid new cookie ('valid' means
             * that the cookie's expire date is not in the past).
             *
             * `first_party` will be used to reject cookies coming from third party
             * resources in case such a security policy is set in the `jar`.
             *
             * `uri` will be used to reject setting or overwriting secure cookies
             * from insecure origins. %NULL is treated as secure.
             *
             * `cookie` will be 'stolen' by the jar, so don't free it afterwards.
             * @param cookie a #SoupCookie
             * @param uri the URI setting the cookie
             * @param first_party the URI for the main document
             */
            add_cookie_full(cookie: Cookie, uri?: URI | null, first_party?: URI | null): void;
            /**
             * Adds `cookie` to `jar,` emitting the 'changed' signal if we are modifying
             * an existing cookie or adding a valid new cookie ('valid' means
             * that the cookie's expire date is not in the past).
             *
             * `first_party` will be used to reject cookies coming from third party
             * resources in case such a security policy is set in the `jar`.
             *
             * `cookie` will be 'stolen' by the jar, so don't free it afterwards.
             *
             * For secure cookies to work properly you may want to use
             * soup_cookie_jar_add_cookie_full().
             * @param first_party the URI for the main document
             * @param cookie a #SoupCookie
             */
            add_cookie_with_first_party(first_party: URI, cookie: Cookie): void;
            /**
             * Constructs a #GSList with every cookie inside the `jar`.
             * The cookies in the list are a copy of the original, so
             * you have to free them when you are done with them.
             * @returns a #GSList with all the cookies in the @jar.
             */
            all_cookies(): Cookie[];
            /**
             * Deletes `cookie` from `jar,` emitting the 'changed' signal.
             * @param cookie a #SoupCookie
             */
            delete_cookie(cookie: Cookie): void;
            /**
             * Gets `jar'`s #SoupCookieJarAcceptPolicy
             * @returns the #SoupCookieJarAcceptPolicy set in the @jar
             */
            get_accept_policy(): CookieJarAcceptPolicy;
            /**
             * Retrieves the list of cookies that would be sent with a request to `uri`
             * as a #GSList of #SoupCookie objects.
             *
             * If `for_http` is %TRUE, the return value will include cookies marked
             * "HttpOnly" (that is, cookies that the server wishes to keep hidden
             * from client-side scripting operations such as the JavaScript
             * document.cookies property). Since #SoupCookieJar sets the Cookie
             * header itself when making the actual HTTP request, you should
             * almost certainly be setting `for_http` to %FALSE if you are calling
             * this.
             * @param uri a #SoupURI
             * @param for_http whether or not the return value is being passed directly to an HTTP operation
             * @returns a #GSList with the cookies in the @jar that would be sent with a request to @uri.
             */
            get_cookie_list(uri: URI, for_http: boolean): Cookie[];
            /**
             * This is an extended version of soup_cookie_jar_get_cookie_list() that
             * provides more information required to use SameSite cookies. See the
             * [SameSite cookies spec](https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00)
             * for more detailed information.
             * @param uri a #SoupURI
             * @param top_level a #SoupURI for the top level document
             * @param site_for_cookies a #SoupURI indicating the origin to get cookies for
             * @param for_http whether or not the return value is being passed directly to an HTTP operation
             * @param is_safe_method if the HTTP method is safe, as defined by RFC 7231, ignored when @for_http is %FALSE
             * @param is_top_level_navigation whether or not the HTTP request is part of top level navigation
             * @returns a #GSList with the cookies in the @jar that would be sent with a request to @uri.
             */
            get_cookie_list_with_same_site_info(
                uri: URI,
                top_level: URI | null,
                site_for_cookies: URI | null,
                for_http: boolean,
                is_safe_method: boolean,
                is_top_level_navigation: boolean,
            ): Cookie[];
            /**
             * Retrieves (in Cookie-header form) the list of cookies that would
             * be sent with a request to `uri`.
             *
             * If `for_http` is %TRUE, the return value will include cookies marked
             * "HttpOnly" (that is, cookies that the server wishes to keep hidden
             * from client-side scripting operations such as the JavaScript
             * document.cookies property). Since #SoupCookieJar sets the Cookie
             * header itself when making the actual HTTP request, you should
             * almost certainly be setting `for_http` to %FALSE if you are calling
             * this.
             * @param uri a #SoupURI
             * @param for_http whether or not the return value is being passed directly to an HTTP operation
             * @returns the cookies, in string form, or %NULL if there are no cookies for @uri.
             */
            get_cookies(uri: URI, for_http: boolean): string | null;
            /**
             * Gets whether `jar` stores cookies persistenly.
             * @returns %TRUE if @jar storage is persistent or %FALSE otherwise.
             */
            is_persistent(): boolean;
            /**
             * This function exists for backward compatibility, but does not do
             * anything any more; cookie jars are saved automatically when they
             * are changed.
             */
            save(): void;
            /**
             * Sets `policy` as the cookie acceptance policy for `jar`.
             * @param policy a #SoupCookieJarAcceptPolicy
             */
            set_accept_policy(policy: CookieJarAcceptPolicy | null): void;
            /**
             * Adds `cookie` to `jar,` exactly as though it had appeared in a
             * Set-Cookie header returned from a request to `uri`.
             *
             * Keep in mind that if the #SoupCookieJarAcceptPolicy set is either
             * %SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY or
             * %SOUP_COOKIE_JAR_ACCEPT_GRANDFATHERED_THIRD_PARTY you'll need to use
             * soup_cookie_jar_set_cookie_with_first_party(), otherwise the jar
             * will have no way of knowing if the cookie is being set by a third
             * party or not.
             * @param uri the URI setting the cookie
             * @param cookie the stringified cookie to set
             */
            set_cookie(uri: URI, cookie: string): void;
            /**
             * Adds `cookie` to `jar,` exactly as though it had appeared in a
             * Set-Cookie header returned from a request to `uri`. `first_party`
             * will be used to reject cookies coming from third party resources in
             * case such a security policy is set in the `jar`.
             * @param uri the URI setting the cookie
             * @param first_party the URI for the main document
             * @param cookie the stringified cookie to set
             */
            set_cookie_with_first_party(uri: URI, first_party: URI, cookie: string): void;

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace CookieJarDB {
            // Signal signatures
            interface SignalSignatures extends CookieJar.SignalSignatures {
                'notify::filename': (pspec: GObject.ParamSpec) => void;
                'notify::accept-policy': (pspec: GObject.ParamSpec) => void;
                'notify::read-only': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends CookieJar.ConstructorProps, SessionFeature.ConstructorProps {
                filename: string;
            }
        }

        class CookieJarDB extends CookieJar implements SessionFeature {
            static $gtype: GObject.GType<CookieJarDB>;

            // Properties

            get filename(): string;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: CookieJarDB.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<CookieJarDB.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](filename: string, read_only: boolean): CookieJarDB;
            // Conflicted with Soup.CookieJar.new

            static ['new'](...args: never[]): any;

            // Signals

            connect<K extends keyof CookieJarDB.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, CookieJarDB.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof CookieJarDB.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, CookieJarDB.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof CookieJarDB.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<CookieJarDB.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace CookieJarText {
            // Signal signatures
            interface SignalSignatures extends CookieJar.SignalSignatures {
                'notify::filename': (pspec: GObject.ParamSpec) => void;
                'notify::accept-policy': (pspec: GObject.ParamSpec) => void;
                'notify::read-only': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends CookieJar.ConstructorProps, SessionFeature.ConstructorProps {
                filename: string;
            }
        }

        class CookieJarText extends CookieJar implements SessionFeature {
            static $gtype: GObject.GType<CookieJarText>;

            // Properties

            get filename(): string;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: CookieJarText.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<CookieJarText.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](filename: string, read_only: boolean): CookieJarText;
            // Conflicted with Soup.CookieJar.new

            static ['new'](...args: never[]): any;

            // Signals

            connect<K extends keyof CookieJarText.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, CookieJarText.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof CookieJarText.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, CookieJarText.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof CookieJarText.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<CookieJarText.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace HSTSEnforcer {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                changed: (arg0: HSTSPolicy, arg1: HSTSPolicy) => void;
                'hsts-enforced': (arg0: Message) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, SessionFeature.ConstructorProps {}
        }

        class HSTSEnforcer extends GObject.Object implements SessionFeature {
            static $gtype: GObject.GType<HSTSEnforcer>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: HSTSEnforcer.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<HSTSEnforcer.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): HSTSEnforcer;

            // Signals

            connect<K extends keyof HSTSEnforcer.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, HSTSEnforcer.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof HSTSEnforcer.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, HSTSEnforcer.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof HSTSEnforcer.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<HSTSEnforcer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            /**
             * the class closure for the #SoupHSTSEnforcer::changed signal.
             * @param old_policy
             * @param new_policy
             */
            vfunc_changed(old_policy: HSTSPolicy, new_policy: HSTSPolicy): void;
            /**
             * Gets whether `hsts_enforcer` has a currently valid policy for `domain`.
             * @param domain a domain.
             */
            vfunc_has_valid_policy(domain: string): boolean;
            vfunc_hsts_enforced(message: Message): void;
            /**
             * Gets whether `hsts_enforcer` stores policies persistenly.
             */
            vfunc_is_persistent(): boolean;

            // Methods

            /**
             * Gets a list of domains for which there are policies in `enforcer`.
             * @param session_policies whether to include session policies
             * @returns a newly allocated list of domains. Use g_list_free_full() and g_free() to free the list.
             */
            get_domains(session_policies: boolean): string[];
            /**
             * Gets a list with the policies in `enforcer`.
             * @param session_policies whether to include session policies
             * @returns a newly allocated list of policies. Use g_list_free_full() and soup_hsts_policy_free() to free the list.
             */
            get_policies(session_policies: boolean): HSTSPolicy[];
            /**
             * Gets whether `hsts_enforcer` has a currently valid policy for `domain`.
             * @param domain a domain.
             * @returns %TRUE if access to @domain should happen over HTTPS, false otherwise.
             */
            has_valid_policy(domain: string): boolean;
            /**
             * Gets whether `hsts_enforcer` stores policies persistenly.
             * @returns %TRUE if @hsts_enforcer storage is persistent or %FALSE otherwise.
             */
            is_persistent(): boolean;
            /**
             * Sets `policy` to `hsts_enforcer`. If `policy` is expired, any
             * existing HSTS policy for its host will be removed instead. If a
             * policy existed for this host, it will be replaced. Otherwise, the
             * new policy will be inserted. If the policy is a session policy, that
             * is, one created with soup_hsts_policy_new_session_policy(), the policy
             * will not expire and will be enforced during the lifetime of
             * `hsts_enforcer'`s #SoupSession.
             * @param policy the policy of the HSTS host
             */
            set_policy(policy: HSTSPolicy): void;
            /**
             * Sets a session policy for `domain`. A session policy is a policy
             * that is permanent to the lifetime of `hsts_enforcer'`s #SoupSession
             * and doesn't expire.
             * @param domain policy domain or hostname
             * @param include_subdomains %TRUE if the policy applies on sub domains
             */
            set_session_policy(domain: string, include_subdomains: boolean): void;

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace HSTSEnforcerDB {
            // Signal signatures
            interface SignalSignatures extends HSTSEnforcer.SignalSignatures {
                'notify::filename': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends HSTSEnforcer.ConstructorProps, SessionFeature.ConstructorProps {
                filename: string;
            }
        }

        class HSTSEnforcerDB extends HSTSEnforcer implements SessionFeature {
            static $gtype: GObject.GType<HSTSEnforcerDB>;

            // Properties

            /**
             * The filename of the SQLite database where HSTS policies are stored.
             */
            get filename(): string;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: HSTSEnforcerDB.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<HSTSEnforcerDB.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](filename: string): HSTSEnforcerDB;
            // Conflicted with Soup.HSTSEnforcer.new

            static ['new'](...args: never[]): any;

            // Signals

            connect<K extends keyof HSTSEnforcerDB.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, HSTSEnforcerDB.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof HSTSEnforcerDB.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, HSTSEnforcerDB.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof HSTSEnforcerDB.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<HSTSEnforcerDB.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Logger {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                'notify::level': (pspec: GObject.ParamSpec) => void;
                'notify::max-body-size': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, SessionFeature.ConstructorProps {
                level: LoggerLogLevel;
                max_body_size: number;
                maxBodySize: number;
            }
        }

        class Logger extends GObject.Object implements SessionFeature {
            static $gtype: GObject.GType<Logger>;

            // Properties

            /**
             * The level of logging output
             */
            get level(): LoggerLogLevel;
            set level(val: LoggerLogLevel);
            /**
             * If #SoupLogger:level is %SOUP_LOGGER_LOG_BODY, this gives
             * the maximum number of bytes of the body that will be logged.
             * (-1 means "no limit".)
             */
            get max_body_size(): number;
            set max_body_size(val: number);
            /**
             * If #SoupLogger:level is %SOUP_LOGGER_LOG_BODY, this gives
             * the maximum number of bytes of the body that will be logged.
             * (-1 means "no limit".)
             */
            get maxBodySize(): number;
            set maxBodySize(val: number);

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: Logger.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<Logger.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](level: LoggerLogLevel, max_body_size: number): Logger;

            // Signals

            connect<K extends keyof Logger.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Logger.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof Logger.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Logger.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof Logger.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<Logger.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Methods

            /**
             * Sets `logger` to watch `session` and print debug information for
             * its messages.
             *
             * (The session will take a reference on `logger,` which will be
             * removed when you call soup_logger_detach(), or when the session is
             * destroyed.)
             * @param session a #SoupSession
             */
            attach(session: Session): void;
            /**
             * Stops `logger` from watching `session`.
             * @param session a #SoupSession
             */
            detach(session: Session): void;
            /**
             * Sets up an alternate log printing routine, if you don't want
             * the log to go to <literal>stdout</literal>.
             * @param printer the callback for printing logging output
             */
            set_printer(printer: LoggerPrinter): void;
            /**
             * Sets up a filter to determine the log level for a given request.
             * For each HTTP request `logger` will invoke `request_filter` to
             * determine how much (if any) of that request to log. (If you do not
             * set a request filter, `logger` will just always log requests at the
             * level passed to soup_logger_new().)
             * @param request_filter the callback for request debugging
             */
            set_request_filter(request_filter: LoggerFilter): void;
            /**
             * Sets up a filter to determine the log level for a given response.
             * For each HTTP response `logger` will invoke `response_filter` to
             * determine how much (if any) of that response to log. (If you do not
             * set a response filter, `logger` will just always log responses at
             * the level passed to soup_logger_new().)
             * @param response_filter the callback for response debugging
             */
            set_response_filter(response_filter: LoggerFilter): void;

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Message {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                'content-sniffed': (arg0: string, arg1: GLib.HashTable<string, string>) => void;
                finished: () => void;
                'got-body': () => void;
                'got-chunk': (arg0: Buffer) => void;
                'got-headers': () => void;
                'got-informational': () => void;
                'network-event': (arg0: Gio.SocketClientEvent, arg1: Gio.IOStream) => void;
                restarted: () => void;
                starting: () => void;
                'wrote-body': () => void;
                'wrote-body-data': (arg0: Buffer) => void;
                'wrote-chunk': () => void;
                'wrote-headers': () => void;
                'wrote-informational': () => void;
                'notify::first-party': (pspec: GObject.ParamSpec) => void;
                'notify::flags': (pspec: GObject.ParamSpec) => void;
                'notify::http-version': (pspec: GObject.ParamSpec) => void;
                'notify::is-top-level-navigation': (pspec: GObject.ParamSpec) => void;
                'notify::method': (pspec: GObject.ParamSpec) => void;
                'notify::priority': (pspec: GObject.ParamSpec) => void;
                'notify::reason-phrase': (pspec: GObject.ParamSpec) => void;
                'notify::request-body': (pspec: GObject.ParamSpec) => void;
                'notify::request-body-data': (pspec: GObject.ParamSpec) => void;
                'notify::request-headers': (pspec: GObject.ParamSpec) => void;
                'notify::response-body': (pspec: GObject.ParamSpec) => void;
                'notify::response-body-data': (pspec: GObject.ParamSpec) => void;
                'notify::response-headers': (pspec: GObject.ParamSpec) => void;
                'notify::server-side': (pspec: GObject.ParamSpec) => void;
                'notify::site-for-cookies': (pspec: GObject.ParamSpec) => void;
                'notify::status-code': (pspec: GObject.ParamSpec) => void;
                'notify::tls-certificate': (pspec: GObject.ParamSpec) => void;
                'notify::tls-errors': (pspec: GObject.ParamSpec) => void;
                'notify::uri': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                first_party: URI;
                firstParty: URI;
                flags: MessageFlags;
                http_version: HTTPVersion;
                httpVersion: HTTPVersion;
                is_top_level_navigation: boolean;
                isTopLevelNavigation: boolean;
                method: string;
                priority: MessagePriority;
                reason_phrase: string;
                reasonPhrase: string;
                request_body: MessageBody;
                requestBody: MessageBody;
                request_body_data: GLib.Bytes;
                requestBodyData: GLib.Bytes;
                request_headers: MessageHeaders;
                requestHeaders: MessageHeaders;
                response_body: MessageBody;
                responseBody: MessageBody;
                response_body_data: GLib.Bytes;
                responseBodyData: GLib.Bytes;
                response_headers: MessageHeaders;
                responseHeaders: MessageHeaders;
                server_side: boolean;
                serverSide: boolean;
                site_for_cookies: URI;
                siteForCookies: URI;
                status_code: number;
                statusCode: number;
                tls_certificate: Gio.TlsCertificate;
                tlsCertificate: Gio.TlsCertificate;
                tls_errors: Gio.TlsCertificateFlags;
                tlsErrors: Gio.TlsCertificateFlags;
                uri: URI;
            }
        }

        /**
         * Represents an HTTP message being sent or received.
         *
         * `status_code` will normally be a #SoupStatus value, eg,
         * %SOUP_STATUS_OK, though of course it might actually be an unknown
         * status code. `reason_phrase` is the actual text returned from the
         * server, which may or may not correspond to the "standard"
         * description of `status_code`. At any rate, it is almost certainly
         * not localized, and not very descriptive even if it is in the user's
         * language; you should not use `reason_phrase` in user-visible
         * messages. Rather, you should look at `status_code,` and determine an
         * end-user-appropriate message based on that and on what you were
         * trying to do.
         *
         * As described in the #SoupMessageBody documentation, the
         * `request_body` and `response_body` <literal>data</literal> fields
         * will not necessarily be filled in at all times. When the body
         * fields are filled in, they will be terminated with a '\0' byte
         * (which is not included in the <literal>length</literal>), so you
         * can use them as ordinary C strings (assuming that you know that the
         * body doesn't have any other '\0' bytes).
         *
         * For a client-side #SoupMessage, `request_body'`s
         * <literal>data</literal> is usually filled in right before libsoup
         * writes the request to the network, but you should not count on
         * this; use soup_message_body_flatten() if you want to ensure that
         * <literal>data</literal> is filled in. If you are not using
         * #SoupRequest to read the response, then `response_body'`s
         * <literal>data</literal> will be filled in before
         * #SoupMessage::finished is emitted. (If you are using #SoupRequest,
         * then the message body is not accumulated by default, so
         * `response_body'`s <literal>data</literal> will always be %NULL.)
         *
         * For a server-side #SoupMessage, `request_body'`s %data will be
         * filled in before #SoupMessage::got_body is emitted.
         *
         * To prevent the %data field from being filled in at all (eg, if you
         * are handling the data from a #SoupMessage::got_chunk, and so don't
         * need to see it all at the end), call
         * soup_message_body_set_accumulate() on `response_body` or
         * `request_body` as appropriate, passing %FALSE.
         */
        class Message extends GObject.Object {
            static $gtype: GObject.GType<Message>;

            // Properties

            /**
             * The #SoupURI loaded in the application when the message was
             * queued.
             */
            get first_party(): URI;
            set first_party(val: URI);
            /**
             * The #SoupURI loaded in the application when the message was
             * queued.
             */
            get firstParty(): URI;
            set firstParty(val: URI);
            get flags(): MessageFlags;
            set flags(val: MessageFlags);
            get http_version(): HTTPVersion;
            set http_version(val: HTTPVersion);
            get httpVersion(): HTTPVersion;
            set httpVersion(val: HTTPVersion);
            /**
             * Set when the message is navigating between top level domains.
             */
            get is_top_level_navigation(): boolean;
            set is_top_level_navigation(val: boolean);
            /**
             * Set when the message is navigating between top level domains.
             */
            get isTopLevelNavigation(): boolean;
            set isTopLevelNavigation(val: boolean);
            get method(): string;
            set method(val: string);
            get priority(): MessagePriority;
            set priority(val: MessagePriority);
            get reason_phrase(): string;
            set reason_phrase(val: string);
            get reasonPhrase(): string;
            set reasonPhrase(val: string);
            get request_body(): MessageBody;
            get requestBody(): MessageBody;
            /**
             * The message's HTTP request body, as a #GBytes.
             */
            get request_body_data(): GLib.Bytes;
            /**
             * The message's HTTP request body, as a #GBytes.
             */
            get requestBodyData(): GLib.Bytes;
            get request_headers(): MessageHeaders;
            get requestHeaders(): MessageHeaders;
            get response_body(): MessageBody;
            get responseBody(): MessageBody;
            /**
             * The message's HTTP response body, as a #GBytes.
             */
            get response_body_data(): GLib.Bytes;
            /**
             * The message's HTTP response body, as a #GBytes.
             */
            get responseBodyData(): GLib.Bytes;
            get response_headers(): MessageHeaders;
            get responseHeaders(): MessageHeaders;
            get server_side(): boolean;
            get serverSide(): boolean;
            get site_for_cookies(): URI;
            set site_for_cookies(val: URI);
            get siteForCookies(): URI;
            set siteForCookies(val: URI);
            get status_code(): number;
            set status_code(val: number);
            get statusCode(): number;
            set statusCode(val: number);
            /**
             * The #GTlsCertificate associated with the message
             */
            get tls_certificate(): Gio.TlsCertificate;
            set tls_certificate(val: Gio.TlsCertificate);
            /**
             * The #GTlsCertificate associated with the message
             */
            get tlsCertificate(): Gio.TlsCertificate;
            set tlsCertificate(val: Gio.TlsCertificate);
            /**
             * The verification errors on #SoupMessage:tls-certificate
             */
            get tls_errors(): Gio.TlsCertificateFlags;
            set tls_errors(val: Gio.TlsCertificateFlags);
            /**
             * The verification errors on #SoupMessage:tls-certificate
             */
            get tlsErrors(): Gio.TlsCertificateFlags;
            set tlsErrors(val: Gio.TlsCertificateFlags);
            get uri(): URI;
            set uri(val: URI);

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: Message.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<Message.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](method: string, uri_string: string): Message;

            static new_from_uri(method: string, uri: URI): Message;

            // Signals

            connect<K extends keyof Message.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Message.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof Message.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Message.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof Message.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<Message.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            vfunc_finished(): void;
            vfunc_got_body(): void;
            vfunc_got_chunk(chunk: Buffer): void;
            vfunc_got_headers(): void;
            vfunc_got_informational(): void;
            vfunc_restarted(): void;
            vfunc_starting(): void;
            vfunc_wrote_body(): void;
            vfunc_wrote_chunk(): void;
            vfunc_wrote_headers(): void;
            vfunc_wrote_informational(): void;

            // Methods

            content_sniffed(content_type: string, params: { [key: string]: any } | GLib.HashTable<any, any>): void;
            /**
             * This disables the actions of #SoupSessionFeature<!-- -->s with the
             * given `feature_type` (or a subclass of that type) on `msg,` so that
             * `msg` is processed as though the feature(s) hadn't been added to the
             * session. Eg, passing #SOUP_TYPE_CONTENT_SNIFFER for `feature_type`
             * will disable Content-Type sniffing on the message.
             *
             * You must call this before queueing `msg` on a session; calling it on
             * a message that has already been queued is undefined. In particular,
             * you cannot call this on a message that is being requeued after a
             * redirect or authentication.
             * @param feature_type the #GType of a #SoupSessionFeature
             */
            disable_feature(feature_type: GObject.GType): void;
            finished(): void;
            /**
             * Gets the address `msg'`s URI points to. After first setting the
             * URI on a message, this will be unresolved, although the message's
             * session will resolve it before sending the message.
             * @returns the address @msg's URI points to
             */
            get_address(): Address;
            /**
             * Gets `msg'`s first-party #SoupURI
             * @returns the @msg's first party #SoupURI
             */
            get_first_party(): URI;
            /**
             * Gets the flags on `msg`
             * @returns the flags
             */
            get_flags(): MessageFlags;
            /**
             * Gets the HTTP version of `msg`. This is the minimum of the
             * version from the request and the version from the response.
             * @returns the HTTP version
             */
            get_http_version(): HTTPVersion;
            /**
             * If `msg` is using https (or attempted to use https but got
             * %SOUP_STATUS_SSL_FAILED), this retrieves the #GTlsCertificate
             * associated with its connection, and the #GTlsCertificateFlags
             * showing what problems, if any, have been found with that
             * certificate.
             *
             * <note><para>This is only meaningful with messages processed by a #SoupSession and is
             * not useful for messages received by a #SoupServer</para></note>
             * @returns %TRUE if @msg used/attempted https, %FALSE if not
             */
            get_https_status(): [boolean, Gio.TlsCertificate, Gio.TlsCertificateFlags];
            get_is_top_level_navigation(): boolean;
            /**
             * Retrieves the #SoupMessagePriority. If not set this value defaults
             * to #SOUP_MESSAGE_PRIORITY_NORMAL.
             * @returns the priority of the message.
             */
            get_priority(): MessagePriority;
            /**
             * Gets `msg'`s site for cookies #SoupURI
             * @returns the @msg's site for cookies #SoupURI
             */
            get_site_for_cookies(): URI;
            /**
             * If `msg` is associated with a #SoupRequest, this returns that
             * request. Otherwise it returns %NULL.
             * @returns @msg's associated #SoupRequest
             */
            get_soup_request(): Request;
            /**
             * Gets `msg'`s URI
             * @returns the URI @msg is targeted for.
             */
            get_uri(): URI;
            got_body(): void;
            got_chunk(chunk: Buffer): void;
            got_headers(): void;
            got_informational(): void;
            /**
             * Get whether #SoupSessionFeature<!-- -->s of the given `feature_type`
             * (or a subclass of that type) are disabled on `msg`.
             * See soup_message_disable_feature().
             * @param feature_type the #GType of a #SoupSessionFeature
             * @returns %TRUE if feature is disabled, or %FALSE otherwise.
             */
            is_feature_disabled(feature_type: GObject.GType): boolean;
            /**
             * Determines whether or not `msg'`s connection can be kept alive for
             * further requests after processing `msg,` based on the HTTP version,
             * Connection header, etc.
             * @returns %TRUE or %FALSE.
             */
            is_keepalive(): boolean;
            restarted(): void;
            /**
             * Sets an alternate chunk-allocation function to use when reading
             * `msg'`s body when using the traditional (ie,
             * non-#SoupRequest<!-- -->-based) API. Every time data is available
             * to read, libsoup will call `allocator,` which should return a
             * #SoupBuffer. (See #SoupChunkAllocator for additional details.)
             * Libsoup will then read data from the network into that buffer, and
             * update the buffer's <literal>length</literal> to indicate how much
             * data it read.
             *
             * Generally, a custom chunk allocator would be used in conjunction
             * with soup_message_body_set_accumulate() %FALSE and
             * #SoupMessage::got_chunk, as part of a strategy to avoid unnecessary
             * copying of data. However, you cannot assume that every call to the
             * allocator will be followed by a call to your
             * #SoupMessage::got_chunk handler; if an I/O error occurs, then the
             * buffer will be unreffed without ever having been used. If your
             * buffer-allocation strategy requires special cleanup, use
             * soup_buffer_new_with_owner() rather than doing the cleanup from the
             * #SoupMessage::got_chunk handler.
             *
             * The other thing to remember when using non-accumulating message
             * bodies is that the buffer passed to the #SoupMessage::got_chunk
             * handler will be unreffed after the handler returns, just as it
             * would be in the non-custom-allocated case. If you want to hand the
             * chunk data off to some other part of your program to use later,
             * you'll need to ref the #SoupBuffer (or its owner, in the
             * soup_buffer_new_with_owner() case) to ensure that the data remains
             * valid.
             * @param allocator the chunk allocator callback
             */
            set_chunk_allocator(allocator: ChunkAllocator): void;
            /**
             * Sets `first_party` as the main document #SoupURI for `msg`. For
             * details of when and how this is used refer to the documentation for
             * #SoupCookieJarAcceptPolicy.
             * @param first_party the #SoupURI for the @msg's first party
             */
            set_first_party(first_party: URI): void;
            /**
             * Sets the specified flags on `msg`.
             * @param flags a set of #SoupMessageFlags values
             */
            set_flags(flags: MessageFlags | null): void;
            /**
             * Sets the HTTP version on `msg`. The default version is
             * %SOUP_HTTP_1_1. Setting it to %SOUP_HTTP_1_0 will prevent certain
             * functionality from being used.
             * @param version the HTTP version
             */
            set_http_version(version: HTTPVersion | null): void;
            /**
             * See the [same-site spec](https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00)
             * for more information.
             * @param is_top_level_navigation if %TRUE indicate the current request is a top-level navigation
             */
            set_is_top_level_navigation(is_top_level_navigation: boolean): void;
            /**
             * Sets the priority of a message. Note that this won't have any
             * effect unless used before the message is added to the session's
             * message processing queue.
             *
             * The message will be placed just before any other previously added
             * message with lower priority (messages with the same priority are
             * processed on a FIFO basis).
             *
             * Setting priorities does not currently work with #SoupSessionSync
             * (or with synchronous messages on a plain #SoupSession) because in
             * the synchronous/blocking case, priority ends up being determined
             * semi-randomly by thread scheduling.
             * @param priority the #SoupMessagePriority
             */
            set_priority(priority: MessagePriority | null): void;
            /**
             * Sets `msg'`s status_code to `status_code` and adds a Location header
             * pointing to `redirect_uri`. Use this from a #SoupServer when you
             * want to redirect the client to another URI.
             *
             * `redirect_uri` can be a relative URI, in which case it is
             * interpreted relative to `msg'`s current URI. In particular, if
             * `redirect_uri` is just a path, it will replace the path
             * <emphasis>and query</emphasis> of `msg'`s URI.
             * @param status_code a 3xx status code
             * @param redirect_uri the URI to redirect @msg to
             */
            set_redirect(status_code: number, redirect_uri: string): void;
            /**
             * Convenience function to set the request body of a #SoupMessage. If
             * `content_type` is %NULL, the request body must be empty as well.
             * @param content_type MIME Content-Type of the body
             * @param req_use a #SoupMemoryUse describing how to handle @req_body
             * @param req_body a data buffer containing the body of the message request.
             */
            set_request(content_type: string | null, req_use: MemoryUse | null, req_body?: Uint8Array | null): void;
            /**
             * Convenience function to set the response body of a #SoupMessage. If
             * `content_type` is %NULL, the response body must be empty as well.
             * @param content_type MIME Content-Type of the body
             * @param resp_use a #SoupMemoryUse describing how to handle @resp_body
             * @param resp_body a data buffer containing the body of the message response.
             */
            set_response(content_type: string | null, resp_use: MemoryUse | null, resp_body?: Uint8Array | null): void;
            /**
             * Sets `site_for_cookies` as the policy URL for same-site cookies for `msg`.
             *
             * It is either the URL of the top-level document or %NULL depending on whether the registrable
             * domain of this document's URL matches the registrable domain of its parent's/opener's
             * URL. For the top-level document it is set to the document's URL.
             *
             * See the [same-site spec](https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00)
             * for more information.
             * @param site_for_cookies the #SoupURI for the @msg's site for cookies
             */
            set_site_for_cookies(site_for_cookies?: URI | null): void;
            /**
             * Sets `msg'`s status code to `status_code`. If `status_code` is a
             * known value, it will also set `msg'`s reason_phrase.
             * @param status_code an HTTP status code
             */
            set_status(status_code: number): void;
            /**
             * Sets `msg'`s status code and reason phrase.
             * @param status_code an HTTP status code
             * @param reason_phrase a description of the status
             */
            set_status_full(status_code: number, reason_phrase: string): void;
            /**
             * Sets `msg'`s URI to `uri`. If `msg` has already been sent and you want
             * to re-send it with the new URI, you need to call
             * soup_session_requeue_message().
             * @param uri the new #SoupURI
             */
            set_uri(uri: URI): void;
            starting(): void;
            wrote_body(): void;
            wrote_body_data(chunk: Buffer): void;
            wrote_chunk(): void;
            wrote_headers(): void;
            wrote_informational(): void;
        }

        namespace MultipartInputStream {
            // Signal signatures
            interface SignalSignatures extends Gio.FilterInputStream.SignalSignatures {
                'notify::message': (pspec: GObject.ParamSpec) => void;
                'notify::base-stream': (pspec: GObject.ParamSpec) => void;
                'notify::close-base-stream': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Gio.FilterInputStream.ConstructorProps,
                    Gio.PollableInputStream.ConstructorProps {
                message: Message;
            }
        }

        class MultipartInputStream extends Gio.FilterInputStream implements Gio.PollableInputStream {
            static $gtype: GObject.GType<MultipartInputStream>;

            // Properties

            get message(): Message;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: MultipartInputStream.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<MultipartInputStream.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](msg: Message, base_stream: Gio.InputStream): MultipartInputStream;

            // Signals

            connect<K extends keyof MultipartInputStream.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, MultipartInputStream.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof MultipartInputStream.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, MultipartInputStream.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof MultipartInputStream.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<MultipartInputStream.SignalSignatures[K]> extends [any, ...infer Q]
                    ? Q
                    : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Methods

            /**
             * Obtains the headers for the part currently being processed. Note
             * that the #SoupMessageHeaders that are returned are owned by the
             * #SoupMultipartInputStream and will be replaced when a call is made
             * to soup_multipart_input_stream_next_part() or its async
             * counterpart, so if keeping the headers is required, a copy must be
             * made.
             *
             * Note that if a part had no headers at all an empty #SoupMessageHeaders
             * will be returned.
             * @returns a #SoupMessageHeaders containing the headers for the part currently being processed or %NULL if the headers failed to parse.
             */
            get_headers(): MessageHeaders | null;
            /**
             * Obtains an input stream for the next part. When dealing with a
             * multipart response the input stream needs to be wrapped in a
             * #SoupMultipartInputStream and this function or its async
             * counterpart need to be called to obtain the first part for
             * reading.
             *
             * After calling this function,
             * soup_multipart_input_stream_get_headers() can be used to obtain the
             * headers for the first part. A read of 0 bytes indicates the end of
             * the part; a new call to this function should be done at that point,
             * to obtain the next part.
             * @param cancellable a #GCancellable
             * @returns a new #GInputStream, or %NULL if there are no more parts
             */
            next_part(cancellable?: Gio.Cancellable | null): Gio.InputStream | null;
            /**
             * Obtains a #GInputStream for the next request. See
             * soup_multipart_input_stream_next_part() for details on the
             * workflow.
             * @param io_priority the I/O priority for the request.
             * @param cancellable a #GCancellable.
             */
            next_part_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
            ): globalThis.Promise<Gio.InputStream | null>;
            /**
             * Obtains a #GInputStream for the next request. See
             * soup_multipart_input_stream_next_part() for details on the
             * workflow.
             * @param io_priority the I/O priority for the request.
             * @param cancellable a #GCancellable.
             * @param callback callback to call when request is satisfied.
             */
            next_part_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Obtains a #GInputStream for the next request. See
             * soup_multipart_input_stream_next_part() for details on the
             * workflow.
             * @param io_priority the I/O priority for the request.
             * @param cancellable a #GCancellable.
             * @param callback callback to call when request is satisfied.
             */
            next_part_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): globalThis.Promise<Gio.InputStream | null> | void;
            /**
             * Finishes an asynchronous request for the next part.
             * @param result a #GAsyncResult.
             * @returns a newly created #GInputStream for reading the next part or %NULL if there are no more parts.
             */
            next_part_finish(result: Gio.AsyncResult): Gio.InputStream | null;

            // Inherited methods
            /**
             * Checks if `stream` is actually pollable. Some classes may implement
             * #GPollableInputStream but have only certain instances of that class
             * be pollable. If this method returns %FALSE, then the behavior of
             * other #GPollableInputStream methods is undefined.
             *
             * For any given stream, the value returned by this method is constant;
             * a stream cannot switch from pollable to non-pollable or vice versa.
             * @returns %TRUE if @stream is pollable, %FALSE if not.
             */
            can_poll(): boolean;
            /**
             * Creates a #GSource that triggers when `stream` can be read, or
             * `cancellable` is triggered or an error occurs. The callback on the
             * source is of the #GPollableSourceFunc type.
             *
             * As with g_pollable_input_stream_is_readable(), it is possible that
             * the stream may not actually be readable even after the source
             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
             * rather than g_input_stream_read() from the callback.
             *
             * The behaviour of this method is undefined if
             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
             * @param cancellable a #GCancellable, or %NULL
             * @returns a new #GSource
             */
            create_source(cancellable?: Gio.Cancellable | null): GLib.Source;
            /**
             * Checks if `stream` can be read.
             *
             * Note that some stream types may not be able to implement this 100%
             * reliably, and it is possible that a call to g_input_stream_read()
             * after this returns %TRUE would still block. To guarantee
             * non-blocking behavior, you should always use
             * g_pollable_input_stream_read_nonblocking(), which will return a
             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
             *
             * The behaviour of this method is undefined if
             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
             * @returns %TRUE if @stream is readable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_input_stream_is_readable() returning %TRUE, and the   next attempt to read will return the error.
             */
            is_readable(): boolean;
            /**
             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
             * with g_input_stream_read(). If `stream` is not currently readable,
             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
             * use g_pollable_input_stream_create_source() to create a #GSource
             * that will be triggered when `stream` is readable.
             *
             * Note that since this method never blocks, you cannot actually
             * use `cancellable` to cancel it. However, it will return an error
             * if `cancellable` has already been cancelled when you call, which
             * may happen if you call this method after a source triggers due
             * to having been cancelled.
             *
             * The behaviour of this method is undefined if
             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
             * @param cancellable a #GCancellable, or %NULL
             * @returns the number of bytes read, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
             */
            read_nonblocking(cancellable?: Gio.Cancellable | null): [number, Uint8Array];
            /**
             * Checks if `stream` is actually pollable. Some classes may implement
             * #GPollableInputStream but have only certain instances of that class
             * be pollable. If this method returns %FALSE, then the behavior of
             * other #GPollableInputStream methods is undefined.
             *
             * For any given stream, the value returned by this method is constant;
             * a stream cannot switch from pollable to non-pollable or vice versa.
             */
            vfunc_can_poll(): boolean;
            /**
             * Creates a #GSource that triggers when `stream` can be read, or
             * `cancellable` is triggered or an error occurs. The callback on the
             * source is of the #GPollableSourceFunc type.
             *
             * As with g_pollable_input_stream_is_readable(), it is possible that
             * the stream may not actually be readable even after the source
             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
             * rather than g_input_stream_read() from the callback.
             *
             * The behaviour of this method is undefined if
             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
             * @param cancellable a #GCancellable, or %NULL
             */
            vfunc_create_source(cancellable?: Gio.Cancellable | null): GLib.Source;
            /**
             * Checks if `stream` can be read.
             *
             * Note that some stream types may not be able to implement this 100%
             * reliably, and it is possible that a call to g_input_stream_read()
             * after this returns %TRUE would still block. To guarantee
             * non-blocking behavior, you should always use
             * g_pollable_input_stream_read_nonblocking(), which will return a
             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
             *
             * The behaviour of this method is undefined if
             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
             */
            vfunc_is_readable(): boolean;
            /**
             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
             * with g_input_stream_read(). If `stream` is not currently readable,
             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
             * use g_pollable_input_stream_create_source() to create a #GSource
             * that will be triggered when `stream` is readable.
             *
             * Note that since this method never blocks, you cannot actually
             * use `cancellable` to cancel it. However, it will return an error
             * if `cancellable` has already been cancelled when you call, which
             * may happen if you call this method after a source triggers due
             * to having been cancelled.
             *
             * The behaviour of this method is undefined if
             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
             */
            vfunc_read_nonblocking(): [number, Uint8Array | null];
            /**
             * Clears the pending flag on `stream`.
             */
            clear_pending(): void;
            /**
             * Closes the stream, releasing resources related to it.
             *
             * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
             * Closing a stream multiple times will not return an error.
             *
             * Streams will be automatically closed when the last reference
             * is dropped, but you might want to call this function to make sure
             * resources are released as early as possible.
             *
             * Some streams might keep the backing store of the stream (e.g. a file descriptor)
             * open after the stream is closed. See the documentation for the individual
             * stream for details.
             *
             * On failure the first error that happened will be reported, but the close
             * operation will finish as much as possible. A stream that failed to
             * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
             * is important to check and report the error to the user.
             *
             * If `cancellable` is not %NULL, then the operation can be cancelled by
             * triggering the cancellable object from another thread. If the operation
             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
             * Cancelling a close will still leave the stream closed, but some streams
             * can use a faster close that doesn't block to e.g. check errors.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE on success, %FALSE on failure
             */
            close(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Requests an asynchronous closes of the stream, releasing resources related to it.
             * When the operation is finished `callback` will be called.
             * You can then call g_input_stream_close_finish() to get the result of the
             * operation.
             *
             * For behaviour details see g_input_stream_close().
             *
             * The asynchronous methods have a default fallback that uses threads to implement
             * asynchronicity, so they are optional for inheriting classes. However, if you
             * override one you must override all.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional cancellable object
             */
            close_async(io_priority: number, cancellable?: Gio.Cancellable | null): globalThis.Promise<boolean>;
            /**
             * Requests an asynchronous closes of the stream, releasing resources related to it.
             * When the operation is finished `callback` will be called.
             * You can then call g_input_stream_close_finish() to get the result of the
             * operation.
             *
             * For behaviour details see g_input_stream_close().
             *
             * The asynchronous methods have a default fallback that uses threads to implement
             * asynchronicity, so they are optional for inheriting classes. However, if you
             * override one you must override all.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional cancellable object
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            close_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Requests an asynchronous closes of the stream, releasing resources related to it.
             * When the operation is finished `callback` will be called.
             * You can then call g_input_stream_close_finish() to get the result of the
             * operation.
             *
             * For behaviour details see g_input_stream_close().
             *
             * The asynchronous methods have a default fallback that uses threads to implement
             * asynchronicity, so they are optional for inheriting classes. However, if you
             * override one you must override all.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional cancellable object
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            close_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): globalThis.Promise<boolean> | void;
            /**
             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
             * @param result a #GAsyncResult.
             * @returns %TRUE if the stream was closed successfully.
             */
            close_finish(result: Gio.AsyncResult): boolean;
            /**
             * Checks if an input stream has pending actions.
             * @returns %TRUE if @stream has pending actions.
             */
            has_pending(): boolean;
            /**
             * Checks if an input stream is closed.
             * @returns %TRUE if the stream is closed.
             */
            is_closed(): boolean;
            /**
             * Tries to read `count` bytes from the stream into the buffer starting at
             * `buffer`. Will block during this read.
             *
             * If count is zero returns zero and does nothing. A value of `count`
             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the number of bytes read into the buffer is returned.
             * It is not an error if this is not the same as the requested size, as it
             * can happen e.g. near the end of a file. Zero is returned on end of file
             * (or if `count` is zero),  but never otherwise.
             *
             * The returned `buffer` is not a nul-terminated string, it can contain nul bytes
             * at any position, and this function doesn't nul-terminate the `buffer`.
             *
             * If `cancellable` is not %NULL, then the operation can be cancelled by
             * triggering the cancellable object from another thread. If the operation
             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
             * operation was partially finished when the operation was cancelled the
             * partial result will be returned, without an error.
             *
             * On error -1 is returned and `error` is set accordingly.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns Number of bytes read, or -1 on error, or 0 on end of file.
             */
            read(cancellable?: Gio.Cancellable | null): [number, Uint8Array];
            /**
             * Tries to read `count` bytes from the stream into the buffer starting at
             * `buffer`. Will block during this read.
             *
             * This function is similar to g_input_stream_read(), except it tries to
             * read as many bytes as requested, only stopping on an error or end of stream.
             *
             * On a successful read of `count` bytes, or if we reached the end of the
             * stream,  %TRUE is returned, and `bytes_read` is set to the number of bytes
             * read into `buffer`.
             *
             * If there is an error during the operation %FALSE is returned and `error`
             * is set to indicate the error status.
             *
             * As a special exception to the normal conventions for functions that
             * use #GError, if this function returns %FALSE (and sets `error)` then
             * `bytes_read` will be set to the number of bytes that were successfully
             * read before the error was encountered.  This functionality is only
             * available from C.  If you need it from another language then you must
             * write your own loop around g_input_stream_read().
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE on success, %FALSE if there was an error
             */
            read_all(cancellable?: Gio.Cancellable | null): [boolean, Uint8Array, number];
            /**
             * Request an asynchronous read of `count` bytes from the stream into the
             * buffer starting at `buffer`.
             *
             * This is the asynchronous equivalent of [method`InputStream`.read_all].
             *
             * Call [method`InputStream`.read_all_finish] to collect the result.
             *
             * Any outstanding I/O request with higher priority (lower numerical
             * value) will be executed before an outstanding request with lower
             * priority. Default priority is %G_PRIORITY_DEFAULT.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional #GCancellable object, %NULL to ignore
             */
            read_all_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
            ): [globalThis.Promise<number>, Uint8Array];
            /**
             * Request an asynchronous read of `count` bytes from the stream into the
             * buffer starting at `buffer`.
             *
             * This is the asynchronous equivalent of [method`InputStream`.read_all].
             *
             * Call [method`InputStream`.read_all_finish] to collect the result.
             *
             * Any outstanding I/O request with higher priority (lower numerical
             * value) will be executed before an outstanding request with lower
             * priority. Default priority is %G_PRIORITY_DEFAULT.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional #GCancellable object, %NULL to ignore
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            read_all_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): Uint8Array;
            /**
             * Request an asynchronous read of `count` bytes from the stream into the
             * buffer starting at `buffer`.
             *
             * This is the asynchronous equivalent of [method`InputStream`.read_all].
             *
             * Call [method`InputStream`.read_all_finish] to collect the result.
             *
             * Any outstanding I/O request with higher priority (lower numerical
             * value) will be executed before an outstanding request with lower
             * priority. Default priority is %G_PRIORITY_DEFAULT.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional #GCancellable object, %NULL to ignore
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            read_all_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): [globalThis.Promise<number> | void, Uint8Array];
            /**
             * Finishes an asynchronous stream read operation started with
             * [method`InputStream`.read_all_async].
             *
             * As a special exception to the normal conventions for functions that
             * use #GError, if this function returns %FALSE (and sets `error)` then
             * `bytes_read` will be set to the number of bytes that were successfully
             * read before the error was encountered.  This functionality is only
             * available from C.  If you need it from another language then you must
             * write your own loop around g_input_stream_read_async().
             * @param result a #GAsyncResult
             * @returns %TRUE on success, %FALSE if there was an error
             */
            read_all_finish(result: Gio.AsyncResult): [boolean, number];
            /**
             * Request an asynchronous read of `count` bytes from the stream into the buffer
             * starting at `buffer`. When the operation is finished `callback` will be called.
             * You can then call g_input_stream_read_finish() to get the result of the
             * operation.
             *
             * During an async request no other sync and async calls are allowed on `stream,` and will
             * result in %G_IO_ERROR_PENDING errors.
             *
             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the number of bytes read into the buffer will be passed to the
             * callback. It is not an error if this is not the same as the requested size, as it
             * can happen e.g. near the end of a file, but generally we try to read
             * as many bytes as requested. Zero is returned on end of file
             * (or if `count` is zero),  but never otherwise.
             *
             * Any outstanding i/o request with higher priority (lower numerical value) will
             * be executed before an outstanding request with lower priority. Default
             * priority is %G_PRIORITY_DEFAULT.
             *
             * The asynchronous methods have a default fallback that uses threads to implement
             * asynchronicity, so they are optional for inheriting classes. However, if you
             * override one you must override all.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            read_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
            ): [globalThis.Promise<number>, Uint8Array];
            /**
             * Request an asynchronous read of `count` bytes from the stream into the buffer
             * starting at `buffer`. When the operation is finished `callback` will be called.
             * You can then call g_input_stream_read_finish() to get the result of the
             * operation.
             *
             * During an async request no other sync and async calls are allowed on `stream,` and will
             * result in %G_IO_ERROR_PENDING errors.
             *
             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the number of bytes read into the buffer will be passed to the
             * callback. It is not an error if this is not the same as the requested size, as it
             * can happen e.g. near the end of a file, but generally we try to read
             * as many bytes as requested. Zero is returned on end of file
             * (or if `count` is zero),  but never otherwise.
             *
             * Any outstanding i/o request with higher priority (lower numerical value) will
             * be executed before an outstanding request with lower priority. Default
             * priority is %G_PRIORITY_DEFAULT.
             *
             * The asynchronous methods have a default fallback that uses threads to implement
             * asynchronicity, so they are optional for inheriting classes. However, if you
             * override one you must override all.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            read_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): Uint8Array;
            /**
             * Request an asynchronous read of `count` bytes from the stream into the buffer
             * starting at `buffer`. When the operation is finished `callback` will be called.
             * You can then call g_input_stream_read_finish() to get the result of the
             * operation.
             *
             * During an async request no other sync and async calls are allowed on `stream,` and will
             * result in %G_IO_ERROR_PENDING errors.
             *
             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the number of bytes read into the buffer will be passed to the
             * callback. It is not an error if this is not the same as the requested size, as it
             * can happen e.g. near the end of a file, but generally we try to read
             * as many bytes as requested. Zero is returned on end of file
             * (or if `count` is zero),  but never otherwise.
             *
             * Any outstanding i/o request with higher priority (lower numerical value) will
             * be executed before an outstanding request with lower priority. Default
             * priority is %G_PRIORITY_DEFAULT.
             *
             * The asynchronous methods have a default fallback that uses threads to implement
             * asynchronicity, so they are optional for inheriting classes. However, if you
             * override one you must override all.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            read_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): [globalThis.Promise<number> | void, Uint8Array];
            /**
             * Like g_input_stream_read(), this tries to read `count` bytes from
             * the stream in a blocking fashion. However, rather than reading into
             * a user-supplied buffer, this will create a new #GBytes containing
             * the data that was read. This may be easier to use from language
             * bindings.
             *
             * If count is zero, returns a zero-length #GBytes and does nothing. A
             * value of `count` larger than %G_MAXSSIZE will cause a
             * %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, a new #GBytes is returned. It is not an error if the
             * size of this object is not the same as the requested size, as it
             * can happen e.g. near the end of a file. A zero-length #GBytes is
             * returned on end of file (or if `count` is zero), but never
             * otherwise.
             *
             * If `cancellable` is not %NULL, then the operation can be cancelled by
             * triggering the cancellable object from another thread. If the operation
             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
             * operation was partially finished when the operation was cancelled the
             * partial result will be returned, without an error.
             *
             * On error %NULL is returned and `error` is set accordingly.
             * @param count maximum number of bytes that will be read from the stream. Common values include 4096 and 8192.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns a new #GBytes, or %NULL on error
             */
            read_bytes(count: number, cancellable?: Gio.Cancellable | null): GLib.Bytes;
            /**
             * Request an asynchronous read of `count` bytes from the stream into a
             * new #GBytes. When the operation is finished `callback` will be
             * called. You can then call g_input_stream_read_bytes_finish() to get the
             * result of the operation.
             *
             * During an async request no other sync and async calls are allowed
             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
             *
             * A value of `count` larger than %G_MAXSSIZE will cause a
             * %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the new #GBytes will be passed to the callback. It is
             * not an error if this is smaller than the requested size, as it can
             * happen e.g. near the end of a file, but generally we try to read as
             * many bytes as requested. Zero is returned on end of file (or if
             * `count` is zero), but never otherwise.
             *
             * Any outstanding I/O request with higher priority (lower numerical
             * value) will be executed before an outstanding request with lower
             * priority. Default priority is %G_PRIORITY_DEFAULT.
             * @param count the number of bytes that will be read from the stream
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            read_bytes_async(
                count: number,
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
            ): globalThis.Promise<GLib.Bytes>;
            /**
             * Request an asynchronous read of `count` bytes from the stream into a
             * new #GBytes. When the operation is finished `callback` will be
             * called. You can then call g_input_stream_read_bytes_finish() to get the
             * result of the operation.
             *
             * During an async request no other sync and async calls are allowed
             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
             *
             * A value of `count` larger than %G_MAXSSIZE will cause a
             * %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the new #GBytes will be passed to the callback. It is
             * not an error if this is smaller than the requested size, as it can
             * happen e.g. near the end of a file, but generally we try to read as
             * many bytes as requested. Zero is returned on end of file (or if
             * `count` is zero), but never otherwise.
             *
             * Any outstanding I/O request with higher priority (lower numerical
             * value) will be executed before an outstanding request with lower
             * priority. Default priority is %G_PRIORITY_DEFAULT.
             * @param count the number of bytes that will be read from the stream
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            read_bytes_async(
                count: number,
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Request an asynchronous read of `count` bytes from the stream into a
             * new #GBytes. When the operation is finished `callback` will be
             * called. You can then call g_input_stream_read_bytes_finish() to get the
             * result of the operation.
             *
             * During an async request no other sync and async calls are allowed
             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
             *
             * A value of `count` larger than %G_MAXSSIZE will cause a
             * %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the new #GBytes will be passed to the callback. It is
             * not an error if this is smaller than the requested size, as it can
             * happen e.g. near the end of a file, but generally we try to read as
             * many bytes as requested. Zero is returned on end of file (or if
             * `count` is zero), but never otherwise.
             *
             * Any outstanding I/O request with higher priority (lower numerical
             * value) will be executed before an outstanding request with lower
             * priority. Default priority is %G_PRIORITY_DEFAULT.
             * @param count the number of bytes that will be read from the stream
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            read_bytes_async(
                count: number,
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): globalThis.Promise<GLib.Bytes> | void;
            /**
             * Finishes an asynchronous stream read-into-#GBytes operation.
             * @param result a #GAsyncResult.
             * @returns the newly-allocated #GBytes, or %NULL on error
             */
            read_bytes_finish(result: Gio.AsyncResult): GLib.Bytes;
            /**
             * Finishes an asynchronous stream read operation.
             * @param result a #GAsyncResult.
             * @returns number of bytes read in, or -1 on error, or 0 on end of file.
             */
            read_finish(result: Gio.AsyncResult): number;
            /**
             * Sets `stream` to have actions pending. If the pending flag is
             * already set or `stream` is closed, it will return %FALSE and set
             * `error`.
             * @returns %TRUE if pending was previously unset and is now set.
             */
            set_pending(): boolean;
            /**
             * Tries to skip `count` bytes from the stream. Will block during the operation.
             *
             * This is identical to g_input_stream_read(), from a behaviour standpoint,
             * but the bytes that are skipped are not returned to the user. Some
             * streams have an implementation that is more efficient than reading the data.
             *
             * This function is optional for inherited classes, as the default implementation
             * emulates it using read.
             *
             * If `cancellable` is not %NULL, then the operation can be cancelled by
             * triggering the cancellable object from another thread. If the operation
             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
             * operation was partially finished when the operation was cancelled the
             * partial result will be returned, without an error.
             * @param count the number of bytes that will be skipped from the stream
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns Number of bytes skipped, or -1 on error
             */
            skip(count: number, cancellable?: Gio.Cancellable | null): number;
            /**
             * Request an asynchronous skip of `count` bytes from the stream.
             * When the operation is finished `callback` will be called.
             * You can then call g_input_stream_skip_finish() to get the result
             * of the operation.
             *
             * During an async request no other sync and async calls are allowed,
             * and will result in %G_IO_ERROR_PENDING errors.
             *
             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the number of bytes skipped will be passed to the callback.
             * It is not an error if this is not the same as the requested size, as it
             * can happen e.g. near the end of a file, but generally we try to skip
             * as many bytes as requested. Zero is returned on end of file
             * (or if `count` is zero), but never otherwise.
             *
             * Any outstanding i/o request with higher priority (lower numerical value)
             * will be executed before an outstanding request with lower priority.
             * Default priority is %G_PRIORITY_DEFAULT.
             *
             * The asynchronous methods have a default fallback that uses threads to
             * implement asynchronicity, so they are optional for inheriting classes.
             * However, if you override one, you must override all.
             * @param count the number of bytes that will be skipped from the stream
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            skip_async(
                count: number,
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
            ): globalThis.Promise<number>;
            /**
             * Request an asynchronous skip of `count` bytes from the stream.
             * When the operation is finished `callback` will be called.
             * You can then call g_input_stream_skip_finish() to get the result
             * of the operation.
             *
             * During an async request no other sync and async calls are allowed,
             * and will result in %G_IO_ERROR_PENDING errors.
             *
             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the number of bytes skipped will be passed to the callback.
             * It is not an error if this is not the same as the requested size, as it
             * can happen e.g. near the end of a file, but generally we try to skip
             * as many bytes as requested. Zero is returned on end of file
             * (or if `count` is zero), but never otherwise.
             *
             * Any outstanding i/o request with higher priority (lower numerical value)
             * will be executed before an outstanding request with lower priority.
             * Default priority is %G_PRIORITY_DEFAULT.
             *
             * The asynchronous methods have a default fallback that uses threads to
             * implement asynchronicity, so they are optional for inheriting classes.
             * However, if you override one, you must override all.
             * @param count the number of bytes that will be skipped from the stream
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            skip_async(
                count: number,
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Request an asynchronous skip of `count` bytes from the stream.
             * When the operation is finished `callback` will be called.
             * You can then call g_input_stream_skip_finish() to get the result
             * of the operation.
             *
             * During an async request no other sync and async calls are allowed,
             * and will result in %G_IO_ERROR_PENDING errors.
             *
             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the number of bytes skipped will be passed to the callback.
             * It is not an error if this is not the same as the requested size, as it
             * can happen e.g. near the end of a file, but generally we try to skip
             * as many bytes as requested. Zero is returned on end of file
             * (or if `count` is zero), but never otherwise.
             *
             * Any outstanding i/o request with higher priority (lower numerical value)
             * will be executed before an outstanding request with lower priority.
             * Default priority is %G_PRIORITY_DEFAULT.
             *
             * The asynchronous methods have a default fallback that uses threads to
             * implement asynchronicity, so they are optional for inheriting classes.
             * However, if you override one, you must override all.
             * @param count the number of bytes that will be skipped from the stream
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            skip_async(
                count: number,
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): globalThis.Promise<number> | void;
            /**
             * Finishes a stream skip operation.
             * @param result a #GAsyncResult.
             * @returns the size of the bytes skipped, or `-1` on error.
             */
            skip_finish(result: Gio.AsyncResult): number;
            /**
             * Requests an asynchronous closes of the stream, releasing resources related to it.
             * When the operation is finished `callback` will be called.
             * You can then call g_input_stream_close_finish() to get the result of the
             * operation.
             *
             * For behaviour details see g_input_stream_close().
             *
             * The asynchronous methods have a default fallback that uses threads to implement
             * asynchronicity, so they are optional for inheriting classes. However, if you
             * override one you must override all.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional cancellable object
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            vfunc_close_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
             * @param result a #GAsyncResult.
             */
            vfunc_close_finish(result: Gio.AsyncResult): boolean;
            vfunc_close_fn(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Request an asynchronous read of `count` bytes from the stream into the buffer
             * starting at `buffer`. When the operation is finished `callback` will be called.
             * You can then call g_input_stream_read_finish() to get the result of the
             * operation.
             *
             * During an async request no other sync and async calls are allowed on `stream,` and will
             * result in %G_IO_ERROR_PENDING errors.
             *
             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the number of bytes read into the buffer will be passed to the
             * callback. It is not an error if this is not the same as the requested size, as it
             * can happen e.g. near the end of a file, but generally we try to read
             * as many bytes as requested. Zero is returned on end of file
             * (or if `count` is zero),  but never otherwise.
             *
             * Any outstanding i/o request with higher priority (lower numerical value) will
             * be executed before an outstanding request with lower priority. Default
             * priority is %G_PRIORITY_DEFAULT.
             *
             * The asynchronous methods have a default fallback that uses threads to implement
             * asynchronicity, so they are optional for inheriting classes. However, if you
             * override one you must override all.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            vfunc_read_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Uint8Array | null;
            /**
             * Finishes an asynchronous stream read operation.
             * @param result a #GAsyncResult.
             */
            vfunc_read_finish(result: Gio.AsyncResult): number;
            vfunc_read_fn(buffer: any | null, count: number, cancellable?: Gio.Cancellable | null): number;
            /**
             * Tries to skip `count` bytes from the stream. Will block during the operation.
             *
             * This is identical to g_input_stream_read(), from a behaviour standpoint,
             * but the bytes that are skipped are not returned to the user. Some
             * streams have an implementation that is more efficient than reading the data.
             *
             * This function is optional for inherited classes, as the default implementation
             * emulates it using read.
             *
             * If `cancellable` is not %NULL, then the operation can be cancelled by
             * triggering the cancellable object from another thread. If the operation
             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
             * operation was partially finished when the operation was cancelled the
             * partial result will be returned, without an error.
             * @param count the number of bytes that will be skipped from the stream
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_skip(count: number, cancellable?: Gio.Cancellable | null): number;
            /**
             * Request an asynchronous skip of `count` bytes from the stream.
             * When the operation is finished `callback` will be called.
             * You can then call g_input_stream_skip_finish() to get the result
             * of the operation.
             *
             * During an async request no other sync and async calls are allowed,
             * and will result in %G_IO_ERROR_PENDING errors.
             *
             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
             *
             * On success, the number of bytes skipped will be passed to the callback.
             * It is not an error if this is not the same as the requested size, as it
             * can happen e.g. near the end of a file, but generally we try to skip
             * as many bytes as requested. Zero is returned on end of file
             * (or if `count` is zero), but never otherwise.
             *
             * Any outstanding i/o request with higher priority (lower numerical value)
             * will be executed before an outstanding request with lower priority.
             * Default priority is %G_PRIORITY_DEFAULT.
             *
             * The asynchronous methods have a default fallback that uses threads to
             * implement asynchronicity, so they are optional for inheriting classes.
             * However, if you override one, you must override all.
             * @param count the number of bytes that will be skipped from the stream
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
             */
            vfunc_skip_async(
                count: number,
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes a stream skip operation.
             * @param result a #GAsyncResult.
             */
            vfunc_skip_finish(result: Gio.AsyncResult): number;
            /**
             * Creates an asynchronous iterator for a Gio.InputStream that reads the stream in chunks.
             *
             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
             *
             * Example:
             * ```js
             * import Gio from "gi://Gio";
             *
             * const textDecoder = new TextDecoder("utf-8");
             *
             * const file = Gio.File.new_for_path("/etc/os-release");
             * const inputStream = file.read(null);
             *
             * for await (const bytes of inputStream.createAsyncIterator(4)) {
             *   log(textDecoder.decode(bytes.toArray()));
             * }
             * ```
             *
             * `returns` An async iterator yielding GLib.Bytes objects
             * @param count Maximum number of bytes to read per chunk (default: 4096)
             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
             */
            createAsyncIterator(count?: number, priority?: number): AsyncIterableIterator<GLib.Bytes>;
            /**
             * Creates a synchronous iterator for a Gio.InputStream that reads the stream in chunks.
             *
             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
             *
             * Example:
             * ```js
             * import Gio from "gi://Gio";
             *
             * const textDecoder = new TextDecoder("utf-8");
             *
             * const file = Gio.File.new_for_path("/etc/os-release");
             * const inputStream = file.read(null);
             *
             * for (const bytes of inputStream.createSyncIterator(4)) {
             *   log(textDecoder.decode(bytes.toArray()));
             * }
             * ```
             *
             * `returns` An iterable yielding GLib.Bytes objects
             * @param count Maximum number of bytes to read per chunk (default: 4096)
             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
             */
            createSyncIterator(count?: number, priority?: number): IterableIterator<GLib.Bytes>;
        }

        namespace ProxyResolverDefault {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                'notify::gproxy-resolver': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends GObject.Object.ConstructorProps,
                    ProxyURIResolver.ConstructorProps,
                    SessionFeature.ConstructorProps {
                gproxy_resolver: Gio.ProxyResolver;
                gproxyResolver: Gio.ProxyResolver;
            }
        }

        class ProxyResolverDefault extends GObject.Object implements ProxyURIResolver, SessionFeature {
            static $gtype: GObject.GType<ProxyResolverDefault>;

            // Properties

            set gproxy_resolver(val: Gio.ProxyResolver);
            set gproxyResolver(val: Gio.ProxyResolver);

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: ProxyResolverDefault.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<ProxyResolverDefault.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof ProxyResolverDefault.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, ProxyResolverDefault.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof ProxyResolverDefault.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, ProxyResolverDefault.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof ProxyResolverDefault.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<ProxyResolverDefault.SignalSignatures[K]> extends [any, ...infer Q]
                    ? Q
                    : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Inherited methods
            /**
             * Asynchronously determines a proxy URI to use for `msg` and calls
             * `callback`.
             * @param uri the #SoupURI you want a proxy for
             * @param async_context the #GMainContext to invoke @callback in
             * @param cancellable a #GCancellable, or %NULL
             * @param callback callback to invoke with the proxy address
             */
            get_proxy_uri_async(
                uri: URI,
                async_context: GLib.MainContext | null,
                cancellable: Gio.Cancellable | null,
                callback: ProxyURIResolverCallback,
            ): void;
            /**
             * Synchronously determines a proxy URI to use for `uri`. If `uri`
             * should be sent via proxy, *`proxy_uri` will be set to the URI of the
             * proxy, else it will be set to %NULL.
             * @param uri the #SoupURI you want a proxy for
             * @param cancellable a #GCancellable, or %NULL
             * @returns %SOUP_STATUS_OK if successful, or a transport-level error.
             */
            get_proxy_uri_sync(uri: URI, cancellable: Gio.Cancellable | null): [number, URI];
            /**
             * Asynchronously determines a proxy URI to use for `msg` and calls
             * `callback`.
             * @param uri the #SoupURI you want a proxy for
             * @param async_context the #GMainContext to invoke @callback in
             * @param cancellable a #GCancellable, or %NULL
             * @param callback callback to invoke with the proxy address
             */
            vfunc_get_proxy_uri_async(
                uri: URI,
                async_context: GLib.MainContext | null,
                cancellable: Gio.Cancellable | null,
                callback: ProxyURIResolverCallback,
            ): void;
            /**
             * Synchronously determines a proxy URI to use for `uri`. If `uri`
             * should be sent via proxy, *`proxy_uri` will be set to the URI of the
             * proxy, else it will be set to %NULL.
             * @param uri the #SoupURI you want a proxy for
             * @param cancellable a #GCancellable, or %NULL
             */
            vfunc_get_proxy_uri_sync(uri: URI, cancellable: Gio.Cancellable | null): [number, URI];
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Request {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                'notify::session': (pspec: GObject.ParamSpec) => void;
                'notify::uri': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, Gio.Initable.ConstructorProps {
                session: Session;
                uri: URI;
            }
        }

        /**
         * A request to retrieve a particular URI.
         */
        class Request extends GObject.Object implements Gio.Initable {
            static $gtype: GObject.GType<Request>;

            // Properties

            /**
             * The request's #SoupSession.
             */
            get session(): Session;
            /**
             * The request URI.
             */
            get uri(): URI;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: Request.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<Request.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof Request.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Request.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof Request.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Request.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof Request.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<Request.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            vfunc_check_uri(uri: URI): boolean;
            /**
             * Gets the length of the data represented by `request`. For most
             * request types, this will not be known until after you call
             * soup_request_send() or soup_request_send_finish().
             */
            vfunc_get_content_length(): number;
            /**
             * Gets the type of the data represented by `request`. For most request
             * types, this will not be known until after you call
             * soup_request_send() or soup_request_send_finish().
             *
             * As in the HTTP Content-Type header, this may include parameters
             * after the MIME type.
             */
            vfunc_get_content_type(): string | null;
            /**
             * Synchronously requests the URI pointed to by `request,` and returns
             * a #GInputStream that can be used to read its contents.
             *
             * Note that you cannot use this method with #SoupRequests attached to
             * a #SoupSessionAsync.
             * @param cancellable a #GCancellable or %NULL
             */
            vfunc_send(cancellable?: Gio.Cancellable | null): Gio.InputStream;
            /**
             * Begins an asynchronously request for the URI pointed to by
             * `request`.
             *
             * Note that you cannot use this method with #SoupRequests attached to
             * a #SoupSessionSync.
             * @param cancellable a #GCancellable or %NULL
             * @param callback a #GAsyncReadyCallback
             */
            vfunc_send_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Gets the result of a soup_request_send_async().
             * @param result the #GAsyncResult
             */
            vfunc_send_finish(result: Gio.AsyncResult): Gio.InputStream;

            // Methods

            /**
             * Gets the length of the data represented by `request`. For most
             * request types, this will not be known until after you call
             * soup_request_send() or soup_request_send_finish().
             * @returns the length of the data represented by @request,   or -1 if not known.
             */
            get_content_length(): number;
            /**
             * Gets the type of the data represented by `request`. For most request
             * types, this will not be known until after you call
             * soup_request_send() or soup_request_send_finish().
             *
             * As in the HTTP Content-Type header, this may include parameters
             * after the MIME type.
             * @returns the type of the data represented by   @request, or %NULL if not known.
             */
            get_content_type(): string | null;
            /**
             * Gets `request'`s #SoupSession
             * @returns @request's #SoupSession
             */
            get_session(): Session;
            /**
             * Gets `request'`s URI
             * @returns @request's URI
             */
            get_uri(): URI;
            /**
             * Synchronously requests the URI pointed to by `request,` and returns
             * a #GInputStream that can be used to read its contents.
             *
             * Note that you cannot use this method with #SoupRequests attached to
             * a #SoupSessionAsync.
             * @param cancellable a #GCancellable or %NULL
             * @returns a #GInputStream that can be used to   read from the URI pointed to by @request.
             */
            send(cancellable?: Gio.Cancellable | null): Gio.InputStream;
            /**
             * Begins an asynchronously request for the URI pointed to by
             * `request`.
             *
             * Note that you cannot use this method with #SoupRequests attached to
             * a #SoupSessionSync.
             * @param cancellable a #GCancellable or %NULL
             */
            send_async(cancellable?: Gio.Cancellable | null): globalThis.Promise<Gio.InputStream>;
            /**
             * Begins an asynchronously request for the URI pointed to by
             * `request`.
             *
             * Note that you cannot use this method with #SoupRequests attached to
             * a #SoupSessionSync.
             * @param cancellable a #GCancellable or %NULL
             * @param callback a #GAsyncReadyCallback
             */
            send_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Begins an asynchronously request for the URI pointed to by
             * `request`.
             *
             * Note that you cannot use this method with #SoupRequests attached to
             * a #SoupSessionSync.
             * @param cancellable a #GCancellable or %NULL
             * @param callback a #GAsyncReadyCallback
             */
            send_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): globalThis.Promise<Gio.InputStream> | void;
            /**
             * Gets the result of a soup_request_send_async().
             * @param result the #GAsyncResult
             * @returns a #GInputStream that can be used to   read from the URI pointed to by @request.
             */
            send_finish(result: Gio.AsyncResult): Gio.InputStream;

            // Inherited methods
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace RequestData {
            // Signal signatures
            interface SignalSignatures extends Request.SignalSignatures {
                'notify::session': (pspec: GObject.ParamSpec) => void;
                'notify::uri': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends Request.ConstructorProps, Gio.Initable.ConstructorProps {}
        }

        class RequestData extends Request implements Gio.Initable {
            static $gtype: GObject.GType<RequestData>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: RequestData.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<RequestData.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof RequestData.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, RequestData.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof RequestData.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, RequestData.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof RequestData.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<RequestData.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Inherited methods
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace RequestFile {
            // Signal signatures
            interface SignalSignatures extends Request.SignalSignatures {
                'notify::session': (pspec: GObject.ParamSpec) => void;
                'notify::uri': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends Request.ConstructorProps, Gio.Initable.ConstructorProps {}
        }

        class RequestFile extends Request implements Gio.Initable {
            static $gtype: GObject.GType<RequestFile>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: RequestFile.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<RequestFile.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof RequestFile.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, RequestFile.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof RequestFile.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, RequestFile.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof RequestFile.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<RequestFile.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Methods

            /**
             * Gets a #GFile corresponding to `file'`s URI
             * @returns a #GFile corresponding to @file
             */
            get_file(): Gio.File;

            // Inherited methods
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace RequestHTTP {
            // Signal signatures
            interface SignalSignatures extends Request.SignalSignatures {
                'notify::session': (pspec: GObject.ParamSpec) => void;
                'notify::uri': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends Request.ConstructorProps, Gio.Initable.ConstructorProps {}
        }

        class RequestHTTP extends Request implements Gio.Initable {
            static $gtype: GObject.GType<RequestHTTP>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: RequestHTTP.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<RequestHTTP.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof RequestHTTP.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, RequestHTTP.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof RequestHTTP.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, RequestHTTP.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof RequestHTTP.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<RequestHTTP.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Methods

            /**
             * Gets a new reference to the #SoupMessage associated to this SoupRequest
             * @returns a new reference to the #SoupMessage
             */
            get_message(): Message;

            // Inherited methods
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Requester {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {}

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, SessionFeature.ConstructorProps {}
        }

        class Requester extends GObject.Object implements SessionFeature {
            static $gtype: GObject.GType<Requester>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: Requester.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<Requester.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): Requester;

            // Signals

            connect<K extends keyof Requester.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Requester.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof Requester.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Requester.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof Requester.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<Requester.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Methods

            request(uri_string: string): Request;
            request_uri(uri: URI): Request;

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Server {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                'request-aborted': (arg0: Message, arg1: ClientContext) => void;
                'request-finished': (arg0: Message, arg1: ClientContext) => void;
                'request-read': (arg0: Message, arg1: ClientContext) => void;
                'request-started': (arg0: Message, arg1: ClientContext) => void;
                'notify::async-context': (pspec: GObject.ParamSpec) => void;
                'notify::http-aliases': (pspec: GObject.ParamSpec) => void;
                'notify::https-aliases': (pspec: GObject.ParamSpec) => void;
                'notify::interface': (pspec: GObject.ParamSpec) => void;
                'notify::port': (pspec: GObject.ParamSpec) => void;
                'notify::raw-paths': (pspec: GObject.ParamSpec) => void;
                'notify::server-header': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-cert-file': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-key-file': (pspec: GObject.ParamSpec) => void;
                'notify::tls-certificate': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                async_context: any;
                asyncContext: any;
                http_aliases: string[];
                httpAliases: string[];
                https_aliases: string[];
                httpsAliases: string[];
                interface: Address;
                port: number;
                raw_paths: boolean;
                rawPaths: boolean;
                server_header: string;
                serverHeader: string;
                ssl_cert_file: string;
                sslCertFile: string;
                ssl_key_file: string;
                sslKeyFile: string;
                tls_certificate: Gio.TlsCertificate;
                tlsCertificate: Gio.TlsCertificate;
            }
        }

        class Server extends GObject.Object {
            static $gtype: GObject.GType<Server>;

            // Properties

            /**
             * The server's #GMainContext, if you are using the old API.
             * Servers created using soup_server_listen() will listen on
             * the #GMainContext that was the thread-default context at
             * the time soup_server_listen() was called.
             */
            get async_context(): any;
            /**
             * The server's #GMainContext, if you are using the old API.
             * Servers created using soup_server_listen() will listen on
             * the #GMainContext that was the thread-default context at
             * the time soup_server_listen() was called.
             */
            get asyncContext(): any;
            /**
             * A %NULL-terminated array of URI schemes that should be
             * considered to be aliases for "http". Eg, if this included
             * <literal>"dav"</literal>, than a URI of
             * <literal>dav://example.com/path</literal> would be treated
             * identically to <literal>http://example.com/path</literal>.
             * In particular, this is needed in cases where a client
             * sends requests with absolute URIs, where those URIs do
             * not use "http:".
             *
             * The default value is an array containing the single element
             * <literal>"*"</literal>, a special value which means that
             * any scheme except "https" is considered to be an alias for
             * "http".
             *
             * See also #SoupServer:https-aliases.
             */
            get http_aliases(): string[];
            set http_aliases(val: string[]);
            /**
             * A %NULL-terminated array of URI schemes that should be
             * considered to be aliases for "http". Eg, if this included
             * <literal>"dav"</literal>, than a URI of
             * <literal>dav://example.com/path</literal> would be treated
             * identically to <literal>http://example.com/path</literal>.
             * In particular, this is needed in cases where a client
             * sends requests with absolute URIs, where those URIs do
             * not use "http:".
             *
             * The default value is an array containing the single element
             * <literal>"*"</literal>, a special value which means that
             * any scheme except "https" is considered to be an alias for
             * "http".
             *
             * See also #SoupServer:https-aliases.
             */
            get httpAliases(): string[];
            set httpAliases(val: string[]);
            /**
             * A comma-delimited list of URI schemes that should be
             * considered to be aliases for "https". See
             * #SoupServer:http-aliases for more information.
             *
             * The default value is %NULL, meaning that no URI schemes
             * are considered aliases for "https".
             */
            get https_aliases(): string[];
            set https_aliases(val: string[]);
            /**
             * A comma-delimited list of URI schemes that should be
             * considered to be aliases for "https". See
             * #SoupServer:http-aliases for more information.
             *
             * The default value is %NULL, meaning that no URI schemes
             * are considered aliases for "https".
             */
            get httpsAliases(): string[];
            set httpsAliases(val: string[]);
            /**
             * The address of the network interface the server is
             * listening on, if you are using the old #SoupServer API.
             * (This will not be set if you use soup_server_listen(),
             * etc.)
             */
            get interface(): Address;
            /**
             * The port the server is listening on, if you are using the
             * old #SoupServer API. (This will not be set if you use
             * soup_server_listen(), etc.)
             */
            get port(): number;
            get raw_paths(): boolean;
            get rawPaths(): boolean;
            /**
             * If non-%NULL, the value to use for the "Server" header on
             * #SoupMessage<!-- -->s processed by this server.
             *
             * The Server header is the server equivalent of the
             * User-Agent header, and provides information about the
             * server and its components. It contains a list of one or
             * more product tokens, separated by whitespace, with the most
             * significant product token coming first. The tokens must be
             * brief, ASCII, and mostly alphanumeric (although "-", "_",
             * and "." are also allowed), and may optionally include a "/"
             * followed by a version string. You may also put comments,
             * enclosed in parentheses, between or after the tokens.
             *
             * Some HTTP server implementations intentionally do not use
             * version numbers in their Server header, so that
             * installations running older versions of the server don't
             * end up advertising their vulnerability to specific security
             * holes.
             *
             * As with #SoupSession:user_agent, if you set a
             * #SoupServer:server_header property that has trailing whitespace,
             * #SoupServer will append its own product token (eg,
             * "<literal>libsoup/2.3.2</literal>") to the end of the
             * header for you.
             */
            get server_header(): string;
            set server_header(val: string);
            /**
             * If non-%NULL, the value to use for the "Server" header on
             * #SoupMessage<!-- -->s processed by this server.
             *
             * The Server header is the server equivalent of the
             * User-Agent header, and provides information about the
             * server and its components. It contains a list of one or
             * more product tokens, separated by whitespace, with the most
             * significant product token coming first. The tokens must be
             * brief, ASCII, and mostly alphanumeric (although "-", "_",
             * and "." are also allowed), and may optionally include a "/"
             * followed by a version string. You may also put comments,
             * enclosed in parentheses, between or after the tokens.
             *
             * Some HTTP server implementations intentionally do not use
             * version numbers in their Server header, so that
             * installations running older versions of the server don't
             * end up advertising their vulnerability to specific security
             * holes.
             *
             * As with #SoupSession:user_agent, if you set a
             * #SoupServer:server_header property that has trailing whitespace,
             * #SoupServer will append its own product token (eg,
             * "<literal>libsoup/2.3.2</literal>") to the end of the
             * header for you.
             */
            get serverHeader(): string;
            set serverHeader(val: string);
            /**
             * Path to a file containing a PEM-encoded certificate.
             *
             * If you set this property and #SoupServer:ssl-key-file at
             * construct time, then soup_server_new() will try to read the
             * files; if it cannot, it will return %NULL, with no explicit
             * indication of what went wrong (and logging a warning with
             * newer versions of glib, since returning %NULL from a
             * constructor is illegal).
             */
            get ssl_cert_file(): string;
            /**
             * Path to a file containing a PEM-encoded certificate.
             *
             * If you set this property and #SoupServer:ssl-key-file at
             * construct time, then soup_server_new() will try to read the
             * files; if it cannot, it will return %NULL, with no explicit
             * indication of what went wrong (and logging a warning with
             * newer versions of glib, since returning %NULL from a
             * constructor is illegal).
             */
            get sslCertFile(): string;
            /**
             * Path to a file containing a PEM-encoded private key. See
             * #SoupServer:ssl-cert-file for more information about how this
             * is used.
             */
            get ssl_key_file(): string;
            /**
             * Path to a file containing a PEM-encoded private key. See
             * #SoupServer:ssl-cert-file for more information about how this
             * is used.
             */
            get sslKeyFile(): string;
            /**
             * A #GTlsCertificate that has a #GTlsCertificate:private-key
             * set. If this is set, then the server will be able to speak
             * https in addition to (or instead of) plain http.
             *
             * Alternatively, you can call soup_server_set_ssl_cert_file()
             * to have #SoupServer read in a a certificate from a file.
             */
            get tls_certificate(): Gio.TlsCertificate;
            /**
             * A #GTlsCertificate that has a #GTlsCertificate:private-key
             * set. If this is set, then the server will be able to speak
             * https in addition to (or instead of) plain http.
             *
             * Alternatively, you can call soup_server_set_ssl_cert_file()
             * to have #SoupServer read in a a certificate from a file.
             */
            get tlsCertificate(): Gio.TlsCertificate;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: Server.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<Server.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof Server.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Server.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof Server.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Server.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof Server.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<Server.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            vfunc_request_aborted(msg: Message, client: ClientContext): void;
            vfunc_request_finished(msg: Message, client: ClientContext): void;
            vfunc_request_read(msg: Message, client: ClientContext): void;
            vfunc_request_started(msg: Message, client: ClientContext): void;

            // Methods

            /**
             * Add a new client stream to the `server`.
             * @param stream a #GIOStream
             * @param local_addr the local #GSocketAddress associated with the @stream
             * @param remote_addr the remote #GSocketAddress associated with the @stream
             * @returns %TRUE on success, %FALSE if the stream could not be accepted or any other error occurred (in which case @error will be set).
             */
            accept_iostream(
                stream: Gio.IOStream,
                local_addr?: Gio.SocketAddress | null,
                remote_addr?: Gio.SocketAddress | null,
            ): boolean;
            /**
             * Adds an authentication domain to `server`. Each auth domain will
             * have the chance to require authentication for each request that
             * comes in; normally auth domains will require authentication for
             * requests on certain paths that they have been set up to watch, or
             * that meet other criteria set by the caller. If an auth domain
             * determines that a request requires authentication (and the request
             * doesn't contain authentication), `server` will automatically reject
             * the request with an appropriate status (401 Unauthorized or 407
             * Proxy Authentication Required). If the request used the
             * "100-continue" Expectation, `server` will reject it before the
             * request body is sent.
             * @param auth_domain a #SoupAuthDomain
             */
            add_auth_domain(auth_domain: AuthDomain): void;
            /**
             * Adds an "early" handler to `server` for requests under `path`. Note
             * that "normal" and "early" handlers are matched up together, so if
             * you add a normal handler for "/foo" and an early handler for
             * "/foo/bar", then a request to "/foo/bar" (or any path below it)
             * will run only the early handler. (But if you add both handlers at
             * the same path, then both will get run.)
             *
             * For requests under `path` (that have not already been assigned a
             * status code by a #SoupAuthDomain or a signal handler), `callback`
             * will be invoked after receiving the request headers, but before
             * receiving the request body; the message's #SoupMessage:method and
             * #SoupMessage:request-headers fields will be filled in.
             *
             * Early handlers are generally used for processing requests with
             * request bodies in a streaming fashion. If you determine that the
             * request will contain a message body, normally you would call
             * soup_message_body_set_accumulate() on the message's
             * #SoupMessage:request-body to turn off request-body accumulation,
             * and connect to the message's #SoupMessage::got-chunk signal to
             * process each chunk as it comes in.
             *
             * To complete the message processing after the full message body has
             * been read, you can either also connect to #SoupMessage::got-body,
             * or else you can register a non-early handler for `path` as well. As
             * long as you have not set the #SoupMessage:status-code by the time
             * #SoupMessage::got-body is emitted, the non-early handler will be
             * run as well.
             * @param path the toplevel path for the handler
             * @param callback callback to invoke for requests under @path
             */
            add_early_handler(path: string | null, callback: ServerCallback): void;
            /**
             * Adds a handler to `server` for requests under `path`. If `path` is
             * %NULL or "/", then this will be the default handler for all
             * requests that don't have a more specific handler. (Note though that
             * if you want to handle requests to the special "*" URI, you must
             * explicitly register a handler for "*"; the default handler will not
             * be used for that case.)
             *
             * For requests under `path` (that have not already been assigned a
             * status code by a #SoupAuthDomain, an early #SoupServerHandler, or a
             * signal handler), `callback` will be invoked after receiving the
             * request body; the message's #SoupMessage:method,
             * #SoupMessage:request-headers, and #SoupMessage:request-body fields
             * will be filled in.
             *
             * After determining what to do with the request, the callback must at
             * a minimum call soup_message_set_status() (or
             * soup_message_set_status_full()) on the message to set the response
             * status code. Additionally, it may set response headers and/or fill
             * in the response body.
             *
             * If the callback cannot fully fill in the response before returning
             * (eg, if it needs to wait for information from a database, or
             * another network server), it should call soup_server_pause_message()
             * to tell `server` to not send the response right away. When the
             * response is ready, call soup_server_unpause_message() to cause it
             * to be sent.
             *
             * To send the response body a bit at a time using "chunked" encoding,
             * first call soup_message_headers_set_encoding() to set
             * %SOUP_ENCODING_CHUNKED on the #SoupMessage:response-headers. Then call
             * soup_message_body_append() (or soup_message_body_append_buffer())
             * to append each chunk as it becomes ready, and
             * soup_server_unpause_message() to make sure it's running. (The
             * server will automatically pause the message if it is using chunked
             * encoding but no more chunks are available.) When you are done, call
             * soup_message_body_complete() to indicate that no more chunks are
             * coming.
             * @param path the toplevel path for the handler
             * @param callback callback to invoke for requests under @path
             */
            add_handler(path: string | null, callback: ServerCallback): void;
            /**
             * Adds a WebSocket handler to `server` for requests under `path`. (If
             * `path` is %NULL or "/", then this will be the default handler for
             * all requests that don't have a more specific handler.)
             *
             * When a path has a WebSocket handler registered, `server` will check
             * incoming requests for WebSocket handshakes after all other handlers
             * have run (unless some earlier handler has already set a status code
             * on the message), and update the request's status, response headers,
             * and response body accordingly.
             *
             * If `origin` is non-%NULL, then only requests containing a matching
             * "Origin" header will be accepted. If `protocols` is non-%NULL, then
             * only requests containing a compatible "Sec-WebSocket-Protocols"
             * header will be accepted. More complicated requirements can be
             * handled by adding a normal handler to `path,` and having it perform
             * whatever checks are needed (possibly calling
             * soup_server_check_websocket_handshake() one or more times), and
             * setting a failure status code if the handshake should be rejected.
             * @param path the toplevel path for the handler
             * @param origin the origin of the connection
             * @param protocols the protocols   supported by this handler
             * @param callback callback to invoke for successful WebSocket requests under @path
             */
            add_websocket_handler(
                path: string | null,
                origin: string | null,
                protocols: string[] | null,
                callback: ServerWebsocketCallback,
            ): void;
            /**
             * Closes and frees `server'`s listening sockets. If you are using the
             * old #SoupServer APIs, this also includes the effect of
             * soup_server_quit().
             *
             * Note that if there are currently requests in progress on `server,`
             * that they will continue to be processed if `server'`s #GMainContext
             * is still running.
             *
             * You can call soup_server_listen(), etc, after calling this function
             * if you want to start listening again.
             */
            disconnect(): void;
            /**
             * Gets `server'`s async_context, if you are using the old API. (With
             * the new API, the server runs in the thread's thread-default
             * #GMainContext, regardless of what this method returns.)
             *
             * This does not add a ref to the context, so you will need to ref it
             * yourself if you want it to outlive its server.
             * @returns @server's #GMainContext, which may be %NULL
             */
            get_async_context(): GLib.MainContext | null;
            /**
             * Gets `server'`s listening socket, if you are using the old API.
             *
             * You should treat this socket as read-only; writing to it or
             * modifiying it may cause `server` to malfunction.
             * @returns the listening socket.
             */
            get_listener(): Socket;
            /**
             * Gets `server'`s list of listening sockets.
             *
             * You should treat these sockets as read-only; writing to or
             * modifiying any of these sockets may cause `server` to malfunction.
             *
             * (Beware that in contrast to the old soup_server_get_listener(), this
             * function returns #GSockets, not #SoupSockets.)
             * @returns a list of listening sockets.
             */
            get_listeners(): Gio.Socket[];
            /**
             * Gets the TCP port that `server` is listening on, if you are using
             * the old API.
             * @returns the port @server is listening on.
             */
            get_port(): number;
            /**
             * Gets a list of URIs corresponding to the interfaces `server` is
             * listening on. These will contain IP addresses, not hostnames, and
             * will also indicate whether the given listener is http or https.
             *
             * Note that if you used soup_server_listen_all(), the returned URIs
             * will use the addresses <literal>0.0.0.0</literal> and
             * <literal>::</literal>, rather than actually returning separate URIs
             * for each interface on the system.
             * @returns a list of #SoupURIs, which you must free when you are done with it.
             */
            get_uris(): URI[];
            /**
             * Checks whether `server` is capable of https.
             *
             * In order for a server to run https, you must call
             * soup_server_set_ssl_cert_file(), or set the
             * #SoupServer:tls-certificate property, to provide it with a
             * certificate to use.
             *
             * If you are using the deprecated single-listener APIs, then a return
             * value of %TRUE indicates that the #SoupServer serves https
             * exclusively. If you are using soup_server_listen(), etc, then a
             * %TRUE return value merely indicates that the server is
             * <emphasis>able</emphasis> to do https, regardless of whether it
             * actually currently is or not. Use soup_server_get_uris() to see if
             * it currently has any https listeners.
             * @returns %TRUE if @server is configured to serve https.
             */
            is_https(): boolean;
            /**
             * This attempts to set up `server` to listen for connections on
             * `address`.
             *
             * If `options` includes %SOUP_SERVER_LISTEN_HTTPS, and `server` has
             * been configured for TLS, then `server` will listen for https
             * connections on this port. Otherwise it will listen for plain http.
             *
             * You may call this method (along with the other "listen" methods)
             * any number of times on a server, if you want to listen on multiple
             * ports, or set up both http and https service.
             *
             * After calling this method, `server` will begin accepting and
             * processing connections as soon as the appropriate #GMainContext is
             * run.
             *
             * Note that #SoupServer never makes use of dual IPv4/IPv6 sockets; if
             * `address` is an IPv6 address, it will only accept IPv6 connections.
             * You must configure IPv4 listening separately.
             * @param address the address of the interface to listen on
             * @param options listening options for this server
             * @returns %TRUE on success, %FALSE if @address could not be bound or any other error occurred (in which case @error will be set).
             */
            listen(address: Gio.SocketAddress, options: ServerListenOptions | null): boolean;
            /**
             * This attempts to set up `server` to listen for connections on all
             * interfaces on the system. (That is, it listens on the addresses
             * <literal>0.0.0.0</literal> and/or <literal>::</literal>, depending
             * on whether `options` includes %SOUP_SERVER_LISTEN_IPV4_ONLY,
             * %SOUP_SERVER_LISTEN_IPV6_ONLY, or neither.) If `port` is specified,
             * `server` will listen on that port. If it is 0, `server` will find an
             * unused port to listen on. (In that case, you can use
             * soup_server_get_uris() to find out what port it ended up choosing.)
             *
             * See soup_server_listen() for more details.
             * @param port the port to listen on, or 0
             * @param options listening options for this server
             * @returns %TRUE on success, %FALSE if @port could not be bound or any other error occurred (in which case @error will be set).
             */
            listen_all(port: number, options: ServerListenOptions | null): boolean;
            /**
             * This attempts to set up `server` to listen for connections on
             * `fd`.
             *
             * See soup_server_listen() for more details.
             *
             * Note that `server` will close `fd` when you free it or call
             * soup_server_disconnect().
             * @param fd the file descriptor of a listening socket
             * @param options listening options for this server
             * @returns %TRUE on success, %FALSE if an error occurred (in which case @error will be set).
             */
            listen_fd(fd: number, options: ServerListenOptions | null): boolean;
            /**
             * This attempts to set up `server` to listen for connections on
             * "localhost" (that is, <literal>127.0.0.1</literal> and/or
             * <literal>::1</literal>, depending on whether `options` includes
             * %SOUP_SERVER_LISTEN_IPV4_ONLY, %SOUP_SERVER_LISTEN_IPV6_ONLY, or
             * neither). If `port` is specified, `server` will listen on that port.
             * If it is 0, `server` will find an unused port to listen on. (In that
             * case, you can use soup_server_get_uris() to find out what port it
             * ended up choosing.)
             *
             * See soup_server_listen() for more details.
             * @param port the port to listen on, or 0
             * @param options listening options for this server
             * @returns %TRUE on success, %FALSE if @port could not be bound or any other error occurred (in which case @error will be set).
             */
            listen_local(port: number, options: ServerListenOptions | null): boolean;
            /**
             * This attempts to set up `server` to listen for connections on
             * `socket`.
             *
             * See soup_server_listen() for more details.
             * @param socket a listening #GSocket
             * @param options listening options for this server
             * @returns %TRUE on success, %FALSE if an error occurred (in which case @error will be set).
             */
            listen_socket(socket: Gio.Socket, options: ServerListenOptions | null): boolean;
            /**
             * Pauses I/O on `msg`. This can be used when you need to return from
             * the server handler without having the full response ready yet. Use
             * soup_server_unpause_message() to resume I/O.
             *
             * This must only be called on #SoupMessages which were created by the
             * #SoupServer and are currently doing I/O, such as those passed into a
             * #SoupServerCallback or emitted in a #SoupServer::request-read signal.
             * @param msg a #SoupMessage associated with @server.
             */
            pause_message(msg: Message): void;
            /**
             * Stops processing for `server,` if you are using the old API. Call
             * this to clean up after soup_server_run_async(), or to terminate a
             * call to soup_server_run().
             *
             * Note that messages currently in progress will continue to be
             * handled, if the main loop associated with the server is resumed or
             * kept running.
             *
             * `server` is still in a working state after this call; you can start
             * and stop a server as many times as you want.
             */
            quit(): void;
            /**
             * Removes `auth_domain` from `server`.
             * @param auth_domain a #SoupAuthDomain
             */
            remove_auth_domain(auth_domain: AuthDomain): void;
            /**
             * Removes all handlers (early and normal) registered at `path`.
             * @param path the toplevel path for the handler
             */
            remove_handler(path: string): void;
            /**
             * Starts `server,` if you are using the old API, causing it to listen
             * for and process incoming connections. Unlike
             * soup_server_run_async(), this creates a #GMainLoop and runs it, and
             * it will not return until someone calls soup_server_quit() to stop
             * the server.
             */
            run(): void;
            /**
             * Starts `server,` if you are using the old API, causing it to listen
             * for and process incoming connections.
             *
             * The server runs in `server'`s #GMainContext. It will not actually
             * perform any processing unless the appropriate main loop is running.
             * In the simple case where you did not set the server's
             * %SOUP_SERVER_ASYNC_CONTEXT property, this means the server will run
             * whenever the glib main loop is running.
             */
            run_async(): void;
            /**
             * Sets `server` up to do https, using the SSL/TLS certificate
             * specified by `ssl_cert_file` and `ssl_key_file` (which may point to
             * the same file).
             *
             * Alternatively, you can set the #SoupServer:tls-certificate property
             * at construction time, if you already have a #GTlsCertificate.
             * @param ssl_cert_file path to a file containing a PEM-encoded SSL/TLS   certificate.
             * @param ssl_key_file path to a file containing a PEM-encoded private key.
             * @returns success or failure.
             */
            set_ssl_cert_file(ssl_cert_file: string, ssl_key_file: string): boolean;
            /**
             * Resumes I/O on `msg`. Use this to resume after calling
             * soup_server_pause_message(), or after adding a new chunk to a
             * chunked response.
             *
             * I/O won't actually resume until you return to the main loop.
             *
             * This must only be called on #SoupMessages which were created by the
             * #SoupServer and are currently doing I/O, such as those passed into a
             * #SoupServerCallback or emitted in a #SoupServer::request-read signal.
             * @param msg a #SoupMessage associated with @server.
             */
            unpause_message(msg: Message): void;
        }

        namespace Session {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                authenticate: (arg0: Message, arg1: Auth, arg2: boolean) => void;
                'connection-created': (arg0: GObject.Object) => void;
                'request-queued': (arg0: Message) => void;
                'request-started': (arg0: Message, arg1: Socket) => void;
                'request-unqueued': (arg0: Message) => void;
                tunneling: (arg0: GObject.Object) => void;
                'notify::accept-language': (pspec: GObject.ParamSpec) => void;
                'notify::accept-language-auto': (pspec: GObject.ParamSpec) => void;
                'notify::async-context': (pspec: GObject.ParamSpec) => void;
                'notify::http-aliases': (pspec: GObject.ParamSpec) => void;
                'notify::https-aliases': (pspec: GObject.ParamSpec) => void;
                'notify::idle-timeout': (pspec: GObject.ParamSpec) => void;
                'notify::local-address': (pspec: GObject.ParamSpec) => void;
                'notify::max-conns': (pspec: GObject.ParamSpec) => void;
                'notify::max-conns-per-host': (pspec: GObject.ParamSpec) => void;
                'notify::proxy-resolver': (pspec: GObject.ParamSpec) => void;
                'notify::proxy-uri': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-ca-file': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-strict': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-use-system-ca-file': (pspec: GObject.ParamSpec) => void;
                'notify::timeout': (pspec: GObject.ParamSpec) => void;
                'notify::tls-database': (pspec: GObject.ParamSpec) => void;
                'notify::tls-interaction': (pspec: GObject.ParamSpec) => void;
                'notify::use-ntlm': (pspec: GObject.ParamSpec) => void;
                'notify::use-thread-context': (pspec: GObject.ParamSpec) => void;
                'notify::user-agent': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                accept_language: string;
                acceptLanguage: string;
                accept_language_auto: boolean;
                acceptLanguageAuto: boolean;
                async_context: any;
                asyncContext: any;
                http_aliases: string[];
                httpAliases: string[];
                https_aliases: string[];
                httpsAliases: string[];
                idle_timeout: number;
                idleTimeout: number;
                local_address: Address;
                localAddress: Address;
                max_conns: number;
                maxConns: number;
                max_conns_per_host: number;
                maxConnsPerHost: number;
                proxy_resolver: Gio.ProxyResolver;
                proxyResolver: Gio.ProxyResolver;
                proxy_uri: URI;
                proxyUri: URI;
                ssl_ca_file: string;
                sslCaFile: string;
                ssl_strict: boolean;
                sslStrict: boolean;
                ssl_use_system_ca_file: boolean;
                sslUseSystemCaFile: boolean;
                timeout: number;
                tls_database: Gio.TlsDatabase;
                tlsDatabase: Gio.TlsDatabase;
                tls_interaction: Gio.TlsInteraction;
                tlsInteraction: Gio.TlsInteraction;
                use_ntlm: boolean;
                useNtlm: boolean;
                use_thread_context: boolean;
                useThreadContext: boolean;
                user_agent: string;
                userAgent: string;
            }
        }

        class Session extends GObject.Object {
            static $gtype: GObject.GType<Session>;

            // Properties

            /**
             * If non-%NULL, the value to use for the "Accept-Language" header
             * on #SoupMessage<!-- -->s sent from this session.
             *
             * Setting this will disable
             * #SoupSession:accept-language-auto.
             */
            get accept_language(): string;
            set accept_language(val: string);
            /**
             * If non-%NULL, the value to use for the "Accept-Language" header
             * on #SoupMessage<!-- -->s sent from this session.
             *
             * Setting this will disable
             * #SoupSession:accept-language-auto.
             */
            get acceptLanguage(): string;
            set acceptLanguage(val: string);
            /**
             * If %TRUE, #SoupSession will automatically set the string
             * for the "Accept-Language" header on every #SoupMessage
             * sent, based on the return value of g_get_language_names().
             *
             * Setting this will override any previous value of
             * #SoupSession:accept-language.
             */
            get accept_language_auto(): boolean;
            set accept_language_auto(val: boolean);
            /**
             * If %TRUE, #SoupSession will automatically set the string
             * for the "Accept-Language" header on every #SoupMessage
             * sent, based on the return value of g_get_language_names().
             *
             * Setting this will override any previous value of
             * #SoupSession:accept-language.
             */
            get acceptLanguageAuto(): boolean;
            set acceptLanguageAuto(val: boolean);
            /**
             * The #GMainContext that miscellaneous session-related
             * asynchronous callbacks are invoked on. (Eg, setting
             * #SoupSession:idle-timeout will add a timeout source on this
             * context.)
             *
             * For a plain #SoupSession, this property is always set to
             * the #GMainContext that is the thread-default at the time
             * the session was created, and cannot be overridden. For the
             * deprecated #SoupSession subclasses, the default value is
             * %NULL, meaning to use the global default #GMainContext.
             *
             * If #SoupSession:use-thread-context is %FALSE, this context
             * will also be used for asynchronous HTTP I/O.
             */
            get async_context(): any;
            /**
             * The #GMainContext that miscellaneous session-related
             * asynchronous callbacks are invoked on. (Eg, setting
             * #SoupSession:idle-timeout will add a timeout source on this
             * context.)
             *
             * For a plain #SoupSession, this property is always set to
             * the #GMainContext that is the thread-default at the time
             * the session was created, and cannot be overridden. For the
             * deprecated #SoupSession subclasses, the default value is
             * %NULL, meaning to use the global default #GMainContext.
             *
             * If #SoupSession:use-thread-context is %FALSE, this context
             * will also be used for asynchronous HTTP I/O.
             */
            get asyncContext(): any;
            /**
             * A %NULL-terminated array of URI schemes that should be
             * considered to be aliases for "http". Eg, if this included
             * <literal>"dav"</literal>, than a URI of
             * <literal>dav://example.com/path</literal> would be treated
             * identically to <literal>http://example.com/path</literal>.
             *
             * In a plain #SoupSession, the default value is %NULL,
             * meaning that only "http" is recognized as meaning "http".
             * In #SoupSessionAsync and #SoupSessionSync, for backward
             * compatibility, the default value is an array containing the
             * single element <literal>"*"</literal>, a special value
             * which means that any scheme except "https" is considered to
             * be an alias for "http".
             *
             * See also #SoupSession:https-aliases.
             */
            get http_aliases(): string[];
            set http_aliases(val: string[]);
            /**
             * A %NULL-terminated array of URI schemes that should be
             * considered to be aliases for "http". Eg, if this included
             * <literal>"dav"</literal>, than a URI of
             * <literal>dav://example.com/path</literal> would be treated
             * identically to <literal>http://example.com/path</literal>.
             *
             * In a plain #SoupSession, the default value is %NULL,
             * meaning that only "http" is recognized as meaning "http".
             * In #SoupSessionAsync and #SoupSessionSync, for backward
             * compatibility, the default value is an array containing the
             * single element <literal>"*"</literal>, a special value
             * which means that any scheme except "https" is considered to
             * be an alias for "http".
             *
             * See also #SoupSession:https-aliases.
             */
            get httpAliases(): string[];
            set httpAliases(val: string[]);
            /**
             * A comma-delimited list of URI schemes that should be
             * considered to be aliases for "https". See
             * #SoupSession:http-aliases for more information.
             *
             * The default value is %NULL, meaning that no URI schemes
             * are considered aliases for "https".
             */
            get https_aliases(): string[];
            set https_aliases(val: string[]);
            /**
             * A comma-delimited list of URI schemes that should be
             * considered to be aliases for "https". See
             * #SoupSession:http-aliases for more information.
             *
             * The default value is %NULL, meaning that no URI schemes
             * are considered aliases for "https".
             */
            get httpsAliases(): string[];
            set httpsAliases(val: string[]);
            /**
             * Connection lifetime (in seconds) when idle. Any connection
             * left idle longer than this will be closed.
             *
             * Although you can change this property at any time, it will
             * only affect newly-created connections, not currently-open
             * ones. You can call soup_session_abort() after setting this
             * if you want to ensure that all future connections will have
             * this timeout value.
             *
             * Note that the default value of 60 seconds only applies to
             * plain #SoupSessions. If you are using #SoupSessionAsync or
             * #SoupSessionSync, the default value is 0 (meaning idle
             * connections will never time out).
             */
            get idle_timeout(): number;
            set idle_timeout(val: number);
            /**
             * Connection lifetime (in seconds) when idle. Any connection
             * left idle longer than this will be closed.
             *
             * Although you can change this property at any time, it will
             * only affect newly-created connections, not currently-open
             * ones. You can call soup_session_abort() after setting this
             * if you want to ensure that all future connections will have
             * this timeout value.
             *
             * Note that the default value of 60 seconds only applies to
             * plain #SoupSessions. If you are using #SoupSessionAsync or
             * #SoupSessionSync, the default value is 0 (meaning idle
             * connections will never time out).
             */
            get idleTimeout(): number;
            set idleTimeout(val: number);
            /**
             * Sets the #SoupAddress to use for the client side of
             * the connection.
             *
             * Use this property if you want for instance to bind the
             * local socket to a specific IP address.
             */
            get local_address(): Address;
            /**
             * Sets the #SoupAddress to use for the client side of
             * the connection.
             *
             * Use this property if you want for instance to bind the
             * local socket to a specific IP address.
             */
            get localAddress(): Address;
            get max_conns(): number;
            set max_conns(val: number);
            get maxConns(): number;
            set maxConns(val: number);
            get max_conns_per_host(): number;
            set max_conns_per_host(val: number);
            get maxConnsPerHost(): number;
            set maxConnsPerHost(val: number);
            /**
             * A #GProxyResolver to use with this session. Setting this
             * will clear the #SoupSession:proxy-uri property, and remove
             * any <type>SoupProxyURIResolver</type> features that have
             * been added to the session.
             *
             * By default, in a plain #SoupSession, this is set to the
             * default #GProxyResolver, but you can set it to %NULL if you
             * don't want to use proxies, or set it to your own
             * #GProxyResolver if you want to control what proxies get
             * used.
             */
            get proxy_resolver(): Gio.ProxyResolver;
            set proxy_resolver(val: Gio.ProxyResolver);
            /**
             * A #GProxyResolver to use with this session. Setting this
             * will clear the #SoupSession:proxy-uri property, and remove
             * any <type>SoupProxyURIResolver</type> features that have
             * been added to the session.
             *
             * By default, in a plain #SoupSession, this is set to the
             * default #GProxyResolver, but you can set it to %NULL if you
             * don't want to use proxies, or set it to your own
             * #GProxyResolver if you want to control what proxies get
             * used.
             */
            get proxyResolver(): Gio.ProxyResolver;
            set proxyResolver(val: Gio.ProxyResolver);
            /**
             * A proxy to use for all http and https requests in this
             * session. Setting this will clear the
             * #SoupSession:proxy-resolver property, and remove any
             * <type>SoupProxyURIResolver</type> features that have been
             * added to the session. Setting this property will also
             * cancel all currently pending messages.
             *
             * Note that #SoupSession will normally handle looking up the
             * user's proxy settings for you; you should only use
             * #SoupSession:proxy-uri if you need to override the user's
             * normal proxy settings.
             *
             * Also note that this proxy will be used for
             * <emphasis>all</emphasis> requests; even requests to
             * <literal>localhost</literal>. If you need more control over
             * proxies, you can create a #GSimpleProxyResolver and set the
             * #SoupSession:proxy-resolver property.
             */
            get proxy_uri(): URI;
            set proxy_uri(val: URI);
            /**
             * A proxy to use for all http and https requests in this
             * session. Setting this will clear the
             * #SoupSession:proxy-resolver property, and remove any
             * <type>SoupProxyURIResolver</type> features that have been
             * added to the session. Setting this property will also
             * cancel all currently pending messages.
             *
             * Note that #SoupSession will normally handle looking up the
             * user's proxy settings for you; you should only use
             * #SoupSession:proxy-uri if you need to override the user's
             * normal proxy settings.
             *
             * Also note that this proxy will be used for
             * <emphasis>all</emphasis> requests; even requests to
             * <literal>localhost</literal>. If you need more control over
             * proxies, you can create a #GSimpleProxyResolver and set the
             * #SoupSession:proxy-resolver property.
             */
            get proxyUri(): URI;
            set proxyUri(val: URI);
            /**
             * File containing SSL CA certificates.
             *
             * If the specified file does not exist or cannot be read,
             * then libsoup will print a warning, and then behave as
             * though it had read in a empty CA file, meaning that all SSL
             * certificates will be considered invalid.
             */
            get ssl_ca_file(): string;
            set ssl_ca_file(val: string);
            /**
             * File containing SSL CA certificates.
             *
             * If the specified file does not exist or cannot be read,
             * then libsoup will print a warning, and then behave as
             * though it had read in a empty CA file, meaning that all SSL
             * certificates will be considered invalid.
             */
            get sslCaFile(): string;
            set sslCaFile(val: string);
            /**
             * Normally, if #SoupSession:tls-database is set (including if
             * it was set via #SoupSession:ssl-use-system-ca-file or
             * #SoupSession:ssl-ca-file), then libsoup will reject any
             * certificate that is invalid (ie, expired) or that is not
             * signed by one of the given CA certificates, and the
             * #SoupMessage will fail with the status
             * %SOUP_STATUS_SSL_FAILED.
             *
             * If you set #SoupSession:ssl-strict to %FALSE, then all
             * certificates will be accepted, and you will need to call
             * soup_message_get_https_status() to distinguish valid from
             * invalid certificates. (This can be used, eg, if you want to
             * accept invalid certificates after giving some sort of
             * warning.)
             *
             * For a plain #SoupSession, if the session has no CA file or
             * TLS database, and this property is %TRUE, then all
             * certificates will be rejected. However, beware that the
             * deprecated #SoupSession subclasses (#SoupSessionAsync and
             * #SoupSessionSync) have the opposite behavior: if there is
             * no CA file or TLS database, then all certificates are always
             * accepted, and this property has no effect.
             */
            get ssl_strict(): boolean;
            set ssl_strict(val: boolean);
            /**
             * Normally, if #SoupSession:tls-database is set (including if
             * it was set via #SoupSession:ssl-use-system-ca-file or
             * #SoupSession:ssl-ca-file), then libsoup will reject any
             * certificate that is invalid (ie, expired) or that is not
             * signed by one of the given CA certificates, and the
             * #SoupMessage will fail with the status
             * %SOUP_STATUS_SSL_FAILED.
             *
             * If you set #SoupSession:ssl-strict to %FALSE, then all
             * certificates will be accepted, and you will need to call
             * soup_message_get_https_status() to distinguish valid from
             * invalid certificates. (This can be used, eg, if you want to
             * accept invalid certificates after giving some sort of
             * warning.)
             *
             * For a plain #SoupSession, if the session has no CA file or
             * TLS database, and this property is %TRUE, then all
             * certificates will be rejected. However, beware that the
             * deprecated #SoupSession subclasses (#SoupSessionAsync and
             * #SoupSessionSync) have the opposite behavior: if there is
             * no CA file or TLS database, then all certificates are always
             * accepted, and this property has no effect.
             */
            get sslStrict(): boolean;
            set sslStrict(val: boolean);
            /**
             * Setting this to %TRUE is equivalent to setting
             * #SoupSession:tls-database to the default system CA database.
             * (and likewise, setting #SoupSession:tls-database to the
             * default database by hand will cause this property to
             * become %TRUE).
             *
             * Setting this to %FALSE (when it was previously %TRUE) will
             * clear the #SoupSession:tls-database field.
             *
             * See #SoupSession:ssl-strict for more information on how
             * https certificate validation is handled.
             *
             * If you are using #SoupSessionAsync or
             * #SoupSessionSync, on libsoup older than 2.74.0, the default value
             * is %FALSE, for backward compatibility.
             */
            get ssl_use_system_ca_file(): boolean;
            set ssl_use_system_ca_file(val: boolean);
            /**
             * Setting this to %TRUE is equivalent to setting
             * #SoupSession:tls-database to the default system CA database.
             * (and likewise, setting #SoupSession:tls-database to the
             * default database by hand will cause this property to
             * become %TRUE).
             *
             * Setting this to %FALSE (when it was previously %TRUE) will
             * clear the #SoupSession:tls-database field.
             *
             * See #SoupSession:ssl-strict for more information on how
             * https certificate validation is handled.
             *
             * If you are using #SoupSessionAsync or
             * #SoupSessionSync, on libsoup older than 2.74.0, the default value
             * is %FALSE, for backward compatibility.
             */
            get sslUseSystemCaFile(): boolean;
            set sslUseSystemCaFile(val: boolean);
            /**
             * The timeout (in seconds) for socket I/O operations
             * (including connecting to a server, and waiting for a reply
             * to an HTTP request).
             *
             * Although you can change this property at any time, it will
             * only affect newly-created connections, not currently-open
             * ones. You can call soup_session_abort() after setting this
             * if you want to ensure that all future connections will have
             * this timeout value.
             *
             * Note that the default value of 60 seconds only applies to
             * plain #SoupSessions. If you are using #SoupSessionAsync or
             * #SoupSessionSync, the default value is 0 (meaning socket I/O
             * will not time out).
             *
             * Not to be confused with #SoupSession:idle-timeout (which is
             * the length of time that idle persistent connections will be
             * kept open).
             */
            get timeout(): number;
            set timeout(val: number);
            /**
             * Sets the #GTlsDatabase to use for validating SSL/TLS
             * certificates.
             *
             * Note that setting the #SoupSession:ssl-ca-file or
             * #SoupSession:ssl-use-system-ca-file property will cause
             * this property to be set to a #GTlsDatabase corresponding to
             * the indicated file or system default.
             *
             * See #SoupSession:ssl-strict for more information on how
             * https certificate validation is handled.
             *
             * If you are using a plain #SoupSession then
             * #SoupSession:ssl-use-system-ca-file will be %TRUE by
             * default, and so this property will be a copy of the system
             * CA database. If you are using #SoupSessionAsync or
             * #SoupSessionSync, on libsoup older than 2.74.0, this property
             * will be %NULL by default.
             */
            get tls_database(): Gio.TlsDatabase;
            set tls_database(val: Gio.TlsDatabase);
            /**
             * Sets the #GTlsDatabase to use for validating SSL/TLS
             * certificates.
             *
             * Note that setting the #SoupSession:ssl-ca-file or
             * #SoupSession:ssl-use-system-ca-file property will cause
             * this property to be set to a #GTlsDatabase corresponding to
             * the indicated file or system default.
             *
             * See #SoupSession:ssl-strict for more information on how
             * https certificate validation is handled.
             *
             * If you are using a plain #SoupSession then
             * #SoupSession:ssl-use-system-ca-file will be %TRUE by
             * default, and so this property will be a copy of the system
             * CA database. If you are using #SoupSessionAsync or
             * #SoupSessionSync, on libsoup older than 2.74.0, this property
             * will be %NULL by default.
             */
            get tlsDatabase(): Gio.TlsDatabase;
            set tlsDatabase(val: Gio.TlsDatabase);
            /**
             * A #GTlsInteraction object that will be passed on to any
             * #GTlsConnections created by the session. (This can be used to
             * provide client-side certificates, for example.)
             */
            get tls_interaction(): Gio.TlsInteraction;
            set tls_interaction(val: Gio.TlsInteraction);
            /**
             * A #GTlsInteraction object that will be passed on to any
             * #GTlsConnections created by the session. (This can be used to
             * provide client-side certificates, for example.)
             */
            get tlsInteraction(): Gio.TlsInteraction;
            set tlsInteraction(val: Gio.TlsInteraction);
            /**
             * Whether or not to use NTLM authentication.
             */
            get use_ntlm(): boolean;
            set use_ntlm(val: boolean);
            /**
             * Whether or not to use NTLM authentication.
             */
            get useNtlm(): boolean;
            set useNtlm(val: boolean);
            /**
             * If %TRUE (which it always is on a plain #SoupSession),
             * asynchronous HTTP requests in this session will run in
             * whatever the thread-default #GMainContext is at the time
             * they are started, rather than always occurring in
             * #SoupSession:async-context.
             */
            get use_thread_context(): boolean;
            set use_thread_context(val: boolean);
            /**
             * If %TRUE (which it always is on a plain #SoupSession),
             * asynchronous HTTP requests in this session will run in
             * whatever the thread-default #GMainContext is at the time
             * they are started, rather than always occurring in
             * #SoupSession:async-context.
             */
            get useThreadContext(): boolean;
            set useThreadContext(val: boolean);
            /**
             * If non-%NULL, the value to use for the "User-Agent" header
             * on #SoupMessage<!-- -->s sent from this session.
             *
             * RFC 2616 says: "The User-Agent request-header field
             * contains information about the user agent originating the
             * request. This is for statistical purposes, the tracing of
             * protocol violations, and automated recognition of user
             * agents for the sake of tailoring responses to avoid
             * particular user agent limitations. User agents SHOULD
             * include this field with requests."
             *
             * The User-Agent header contains a list of one or more
             * product tokens, separated by whitespace, with the most
             * significant product token coming first. The tokens must be
             * brief, ASCII, and mostly alphanumeric (although "-", "_",
             * and "." are also allowed), and may optionally include a "/"
             * followed by a version string. You may also put comments,
             * enclosed in parentheses, between or after the tokens.
             *
             * If you set a #SoupSession:user_agent property that has trailing
             * whitespace, #SoupSession will append its own product token
             * (eg, "<literal>libsoup/2.3.2</literal>") to the end of the
             * header for you.
             */
            get user_agent(): string;
            set user_agent(val: string);
            /**
             * If non-%NULL, the value to use for the "User-Agent" header
             * on #SoupMessage<!-- -->s sent from this session.
             *
             * RFC 2616 says: "The User-Agent request-header field
             * contains information about the user agent originating the
             * request. This is for statistical purposes, the tracing of
             * protocol violations, and automated recognition of user
             * agents for the sake of tailoring responses to avoid
             * particular user agent limitations. User agents SHOULD
             * include this field with requests."
             *
             * The User-Agent header contains a list of one or more
             * product tokens, separated by whitespace, with the most
             * significant product token coming first. The tokens must be
             * brief, ASCII, and mostly alphanumeric (although "-", "_",
             * and "." are also allowed), and may optionally include a "/"
             * followed by a version string. You may also put comments,
             * enclosed in parentheses, between or after the tokens.
             *
             * If you set a #SoupSession:user_agent property that has trailing
             * whitespace, #SoupSession will append its own product token
             * (eg, "<literal>libsoup/2.3.2</literal>") to the end of the
             * header for you.
             */
            get userAgent(): string;
            set userAgent(val: string);

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: Session.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<Session.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): Session;

            // Signals

            connect<K extends keyof Session.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Session.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof Session.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Session.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof Session.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<Session.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            vfunc_auth_required(msg: Message, auth: Auth, retrying: boolean): void;
            vfunc_authenticate(msg: Message, auth: Auth, retrying: boolean): void;
            /**
             * Causes `session` to immediately finish processing `msg` (regardless
             * of its current state) with a final status_code of `status_code`. You
             * may call this at any time after handing `msg` off to `session;` if
             * `session` has started sending the request but has not yet received
             * the complete response, then it will close the request's connection.
             * Note that with requests that have side effects (eg,
             * <literal>POST</literal>, <literal>PUT</literal>,
             * <literal>DELETE</literal>) it is possible that you might cancel the
             * request after the server acts on it, but before it returns a
             * response, leaving the remote resource in an unknown state.
             *
             * If the message is cancelled while its response body is being read,
             * then the response body in `msg` will be left partially-filled-in.
             * The response headers, on the other hand, will always be either
             * empty or complete.
             *
             * Beware that with the deprecated #SoupSessionAsync, messages queued
             * with soup_session_queue_message() will have their callbacks invoked
             * before soup_session_cancel_message() returns. The plain
             * #SoupSession does not have this behavior; cancelling an
             * asynchronous message will merely queue its callback to be run after
             * returning to the main loop.
             * @param msg the message to cancel
             * @param status_code status code to set on @msg (generally %SOUP_STATUS_CANCELLED)
             */
            vfunc_cancel_message(msg: Message, status_code: number): void;
            vfunc_flush_queue(): void;
            vfunc_kick(): void;
            /**
             * Queues the message `msg` for asynchronously sending the request and
             * receiving a response in the current thread-default #GMainContext.
             * If `msg` has been processed before, any resources related to the
             * time it was last sent are freed.
             *
             * Upon message completion, the callback specified in `callback` will
             * be invoked. If after returning from this callback the message has not
             * been requeued, `msg` will be unreffed.
             *
             * (The behavior above applies to a plain #SoupSession; if you are
             * using #SoupSessionAsync or #SoupSessionSync, then the #GMainContext
             * that is used depends on the settings of #SoupSession:async-context
             * and #SoupSession:use-thread-context, and for #SoupSessionSync, the
             * message will actually be sent and processed in another thread, with
             * only the final callback occurring in the indicated #GMainContext.)
             *
             * Contrast this method with soup_session_send_async(), which also
             * asynchronously sends a message, but returns before reading the
             * response body, and allows you to read the response via a
             * #GInputStream.
             * @param msg the message to queue
             * @param callback a #SoupSessionCallback which will be called after the message completes or when an unrecoverable error occurs.
             */
            vfunc_queue_message(msg: Message, callback?: SessionCallback | null): void;
            vfunc_request_started(msg: Message, socket: Socket): void;
            /**
             * This causes `msg` to be placed back on the queue to be attempted
             * again.
             * @param msg the message to requeue
             */
            vfunc_requeue_message(msg: Message): void;
            /**
             * Synchronously send `msg`. This call will not return until the
             * transfer is finished successfully or there is an unrecoverable
             * error.
             *
             * Unlike with soup_session_queue_message(), `msg` is not freed upon
             * return.
             *
             * (Note that if you call this method on a #SoupSessionAsync, it will
             * still use asynchronous I/O internally, running the glib main loop
             * to process the message, which may also cause other events to be
             * processed.)
             *
             * Contrast this method with soup_session_send(), which also
             * synchronously sends a message, but returns before reading the
             * response body, and allows you to read the response via a
             * #GInputStream.
             * @param msg the message to send
             */
            vfunc_send_message(msg: Message): number;

            // Methods

            /**
             * Cancels all pending requests in `session` and closes all idle
             * persistent connections.
             *
             * The message cancellation has the same semantics as with
             * soup_session_cancel_message(); asynchronous requests on a
             * #SoupSessionAsync will have their callback called before
             * soup_session_abort() returns. Requests on a plain #SoupSession will
             * not.
             */
            abort(): void;
            /**
             * Causes `session` to immediately finish processing `msg` (regardless
             * of its current state) with a final status_code of `status_code`. You
             * may call this at any time after handing `msg` off to `session;` if
             * `session` has started sending the request but has not yet received
             * the complete response, then it will close the request's connection.
             * Note that with requests that have side effects (eg,
             * <literal>POST</literal>, <literal>PUT</literal>,
             * <literal>DELETE</literal>) it is possible that you might cancel the
             * request after the server acts on it, but before it returns a
             * response, leaving the remote resource in an unknown state.
             *
             * If the message is cancelled while its response body is being read,
             * then the response body in `msg` will be left partially-filled-in.
             * The response headers, on the other hand, will always be either
             * empty or complete.
             *
             * Beware that with the deprecated #SoupSessionAsync, messages queued
             * with soup_session_queue_message() will have their callbacks invoked
             * before soup_session_cancel_message() returns. The plain
             * #SoupSession does not have this behavior; cancelling an
             * asynchronous message will merely queue its callback to be run after
             * returning to the main loop.
             * @param msg the message to cancel
             * @param status_code status code to set on @msg (generally %SOUP_STATUS_CANCELLED)
             */
            cancel_message(msg: Message, status_code: number): void;
            /**
             * Start a connection to `uri`. The operation can be monitored by providing a `progress_callback`
             * and finishes when the connection is done or an error ocurred.
             *
             * Call soup_session_connect_finish() to get the #GIOStream to communicate with the server.
             * @param uri a #SoupURI to connect to
             * @param cancellable a #GCancellable
             * @param progress_callback a #SoupSessionConnectProgressCallback which will be called for every network event that occurs during the connection.
             */
            connect_async(
                uri: URI,
                cancellable?: Gio.Cancellable | null,
                progress_callback?: SessionConnectProgressCallback | null,
            ): globalThis.Promise<Gio.IOStream>;
            /**
             * Start a connection to `uri`. The operation can be monitored by providing a `progress_callback`
             * and finishes when the connection is done or an error ocurred.
             *
             * Call soup_session_connect_finish() to get the #GIOStream to communicate with the server.
             * @param uri a #SoupURI to connect to
             * @param cancellable a #GCancellable
             * @param progress_callback a #SoupSessionConnectProgressCallback which will be called for every network event that occurs during the connection.
             * @param callback the callback to invoke when the operation finishes
             */
            connect_async(
                uri: URI,
                cancellable: Gio.Cancellable | null,
                progress_callback: SessionConnectProgressCallback | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Start a connection to `uri`. The operation can be monitored by providing a `progress_callback`
             * and finishes when the connection is done or an error ocurred.
             *
             * Call soup_session_connect_finish() to get the #GIOStream to communicate with the server.
             * @param uri a #SoupURI to connect to
             * @param cancellable a #GCancellable
             * @param progress_callback a #SoupSessionConnectProgressCallback which will be called for every network event that occurs during the connection.
             * @param callback the callback to invoke when the operation finishes
             */
            connect_async(
                uri: URI,
                cancellable?: Gio.Cancellable | null,
                progress_callback?: SessionConnectProgressCallback | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): globalThis.Promise<Gio.IOStream> | void;
            /**
             * Gets the #GIOStream created for the connection to communicate with the server.
             * @param result the #GAsyncResult passed to your callback
             * @returns a new #GIOStream, or %NULL on error.
             */
            connect_finish(result: Gio.AsyncResult): Gio.IOStream;
            /**
             * Gets `session'`s #SoupSession:async-context. This does not add a ref
             * to the context, so you will need to ref it yourself if you want it
             * to outlive its session.
             *
             * For a modern #SoupSession, this will always just return the
             * thread-default #GMainContext, and so is not especially useful.
             * @returns @session's #GMainContext, which may be %NULL
             */
            get_async_context(): GLib.MainContext | null;
            /**
             * Gets the first feature in `session` of type `feature_type`. For
             * features where there may be more than one feature of a given type,
             * use soup_session_get_features().
             * @param feature_type the #GType of the feature to get
             * @returns a #SoupSessionFeature, or %NULL. The feature is owned by @session.
             */
            get_feature(feature_type: GObject.GType): SessionFeature | null;
            /**
             * Gets the first feature in `session` of type `feature_type,` provided
             * that it is not disabled for `msg`. As with
             * soup_session_get_feature(), this should only be used for features
             * where `feature_type` is only expected to match a single feature. In
             * particular, if there are two matching features, and the first is
             * disabled on `msg,` and the second is not, then this will return
             * %NULL, not the second feature.
             * @param feature_type the #GType of the feature to get
             * @param msg a #SoupMessage
             * @returns a #SoupSessionFeature, or %NULL. The feature is owned by @session.
             */
            get_feature_for_message(feature_type: GObject.GType, msg: Message): SessionFeature | null;
            /**
             * Generates a list of `session'`s features of type `feature_type`. (If
             * you want to see all features, you can pass %SOUP_TYPE_SESSION_FEATURE
             * for `feature_type`.)
             * @param feature_type the #GType of the class of features to get
             * @returns a list of features. You must free the list, but not its contents
             */
            get_features(feature_type: GObject.GType): SessionFeature[];
            /**
             * Tests if `session` has at a feature of type `feature_type` (which can
             * be the type of either a #SoupSessionFeature, or else a subtype of
             * some class managed by another feature, such as #SoupAuth or
             * #SoupRequest).
             * @param feature_type the #GType of the class of features to check for
             * @returns %TRUE or %FALSE
             */
            has_feature(feature_type: GObject.GType): boolean;
            /**
             * Pauses HTTP I/O on `msg`. Call soup_session_unpause_message() to
             * resume I/O.
             *
             * This may only be called for asynchronous messages (those sent on a
             * #SoupSessionAsync or using soup_session_queue_message()).
             * @param msg a #SoupMessage currently running on @session
             */
            pause_message(msg: Message): void;
            /**
             * Tells `session` that an URI from the given `hostname` may be requested
             * shortly, and so the session can try to prepare by resolving the
             * domain name in advance, in order to work more quickly once the URI
             * is actually requested.
             *
             * If `cancellable` is non-%NULL, it can be used to cancel the
             * resolution. `callback` will still be invoked in this case, with a
             * status of %SOUP_STATUS_CANCELLED.
             * @param hostname a hostname to be resolved
             * @param cancellable a #GCancellable object, or %NULL
             * @param callback callback to call with the     result, or %NULL
             */
            prefetch_dns(
                hostname: string,
                cancellable?: Gio.Cancellable | null,
                callback?: AddressCallback | null,
            ): void;
            /**
             * Tells `session` that `uri` may be requested shortly, and so the
             * session can try to prepare (resolving the domain name, obtaining
             * proxy address, etc.) in order to work more quickly once the URI is
             * actually requested.
             * @param uri a #SoupURI which may be required
             */
            prepare_for_uri(uri: URI): void;
            /**
             * Queues the message `msg` for asynchronously sending the request and
             * receiving a response in the current thread-default #GMainContext.
             * If `msg` has been processed before, any resources related to the
             * time it was last sent are freed.
             *
             * Upon message completion, the callback specified in `callback` will
             * be invoked. If after returning from this callback the message has not
             * been requeued, `msg` will be unreffed.
             *
             * (The behavior above applies to a plain #SoupSession; if you are
             * using #SoupSessionAsync or #SoupSessionSync, then the #GMainContext
             * that is used depends on the settings of #SoupSession:async-context
             * and #SoupSession:use-thread-context, and for #SoupSessionSync, the
             * message will actually be sent and processed in another thread, with
             * only the final callback occurring in the indicated #GMainContext.)
             *
             * Contrast this method with soup_session_send_async(), which also
             * asynchronously sends a message, but returns before reading the
             * response body, and allows you to read the response via a
             * #GInputStream.
             * @param msg the message to queue
             * @param callback a #SoupSessionCallback which will be called after the message completes or when an unrecoverable error occurs.
             */
            queue_message(msg: Message, callback?: SessionCallback | null): void;
            /**
             * Updates `msg'`s URI according to its status code and "Location"
             * header, and requeues it on `session`. Use this when you have set
             * %SOUP_MESSAGE_NO_REDIRECT on a message, but have decided to allow a
             * particular redirection to occur, or if you want to allow a
             * redirection that #SoupSession will not perform automatically (eg,
             * redirecting a non-safe method such as DELETE).
             *
             * If `msg'`s status code indicates that it should be retried as a GET
             * request, then `msg` will be modified accordingly.
             *
             * If `msg` has already been redirected too many times, this will
             * cause it to fail with %SOUP_STATUS_TOO_MANY_REDIRECTS.
             * @param msg a #SoupMessage that has received a 3xx response
             * @returns %TRUE if a redirection was applied, %FALSE if not (eg, because there was no Location header, or it could not be parsed).
             */
            redirect_message(msg: Message): boolean;
            /**
             * Removes `feature'`s functionality from `session`.
             * @param feature a feature that has previously been added to @session
             */
            remove_feature(feature: SessionFeature): void;
            /**
             * Creates a #SoupRequest for retrieving `uri_string`.
             * @param uri_string a URI, in string form
             * @returns a new #SoupRequest, or   %NULL on error.
             */
            request(uri_string: string): Request;
            /**
             * Creates a #SoupRequest for retrieving `uri_string,` which must be an
             * "http" or "https" URI (or another protocol listed in `session'`s
             * #SoupSession:http-aliases or #SoupSession:https-aliases).
             * @param method an HTTP method
             * @param uri_string a URI, in string form
             * @returns a new #SoupRequestHTTP, or   %NULL on error.
             */
            request_http(method: string, uri_string: string): RequestHTTP;
            /**
             * Creates a #SoupRequest for retrieving `uri,` which must be an
             * "http" or "https" URI (or another protocol listed in `session'`s
             * #SoupSession:http-aliases or #SoupSession:https-aliases).
             * @param method an HTTP method
             * @param uri a #SoupURI representing the URI to retrieve
             * @returns a new #SoupRequestHTTP, or   %NULL on error.
             */
            request_http_uri(method: string, uri: URI): RequestHTTP;
            /**
             * Creates a #SoupRequest for retrieving `uri`.
             * @param uri a #SoupURI representing the URI to retrieve
             * @returns a new #SoupRequest, or   %NULL on error.
             */
            request_uri(uri: URI): Request;
            /**
             * This causes `msg` to be placed back on the queue to be attempted
             * again.
             * @param msg the message to requeue
             */
            requeue_message(msg: Message): void;
            /**
             * Synchronously sends `msg` and waits for the beginning of a response.
             * On success, a #GInputStream will be returned which you can use to
             * read the response body. ("Success" here means only that an HTTP
             * response was received and understood; it does not necessarily mean
             * that a 2xx class status code was received.)
             *
             * If non-%NULL, `cancellable` can be used to cancel the request;
             * soup_session_send() will return a %G_IO_ERROR_CANCELLED error. Note
             * that with requests that have side effects (eg,
             * <literal>POST</literal>, <literal>PUT</literal>,
             * <literal>DELETE</literal>) it is possible that you might cancel the
             * request after the server acts on it, but before it returns a
             * response, leaving the remote resource in an unknown state.
             *
             * If `msg` is requeued due to a redirect or authentication, the
             * initial (3xx/401/407) response body will be suppressed, and
             * soup_session_send() will only return once a final response has been
             * received.
             *
             * Contrast this method with soup_session_send_message(), which also
             * synchronously sends a #SoupMessage, but doesn't return until the
             * response has been completely read.
             *
             * (Note that this method cannot be called on the deprecated
             * #SoupSessionAsync subclass.)
             * @param msg a #SoupMessage
             * @param cancellable a #GCancellable
             * @returns a #GInputStream for reading the   response body, or %NULL on error.
             */
            send(msg: Message, cancellable?: Gio.Cancellable | null): Gio.InputStream;
            /**
             * Asynchronously sends `msg` and waits for the beginning of a
             * response. When `callback` is called, then either `msg` has been sent,
             * and its response headers received, or else an error has occurred.
             * Call soup_session_send_finish() to get a #GInputStream for reading
             * the response body.
             *
             * See soup_session_send() for more details on the general semantics.
             *
             * Contrast this method with soup_session_queue_message(), which also
             * asynchronously sends a #SoupMessage, but doesn't invoke its
             * callback until the response has been completely read.
             *
             * (Note that this method cannot be called on the deprecated
             * #SoupSessionSync subclass, and can only be called on
             * #SoupSessionAsync if you have set the
             * #SoupSession:use-thread-context property.)
             * @param msg a #SoupMessage
             * @param cancellable a #GCancellable
             */
            send_async(msg: Message, cancellable?: Gio.Cancellable | null): globalThis.Promise<Gio.InputStream>;
            /**
             * Asynchronously sends `msg` and waits for the beginning of a
             * response. When `callback` is called, then either `msg` has been sent,
             * and its response headers received, or else an error has occurred.
             * Call soup_session_send_finish() to get a #GInputStream for reading
             * the response body.
             *
             * See soup_session_send() for more details on the general semantics.
             *
             * Contrast this method with soup_session_queue_message(), which also
             * asynchronously sends a #SoupMessage, but doesn't invoke its
             * callback until the response has been completely read.
             *
             * (Note that this method cannot be called on the deprecated
             * #SoupSessionSync subclass, and can only be called on
             * #SoupSessionAsync if you have set the
             * #SoupSession:use-thread-context property.)
             * @param msg a #SoupMessage
             * @param cancellable a #GCancellable
             * @param callback the callback to invoke
             */
            send_async(
                msg: Message,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously sends `msg` and waits for the beginning of a
             * response. When `callback` is called, then either `msg` has been sent,
             * and its response headers received, or else an error has occurred.
             * Call soup_session_send_finish() to get a #GInputStream for reading
             * the response body.
             *
             * See soup_session_send() for more details on the general semantics.
             *
             * Contrast this method with soup_session_queue_message(), which also
             * asynchronously sends a #SoupMessage, but doesn't invoke its
             * callback until the response has been completely read.
             *
             * (Note that this method cannot be called on the deprecated
             * #SoupSessionSync subclass, and can only be called on
             * #SoupSessionAsync if you have set the
             * #SoupSession:use-thread-context property.)
             * @param msg a #SoupMessage
             * @param cancellable a #GCancellable
             * @param callback the callback to invoke
             */
            send_async(
                msg: Message,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): globalThis.Promise<Gio.InputStream> | void;
            /**
             * Gets the response to a soup_session_send_async() call and (if
             * successful), returns a #GInputStream that can be used to read the
             * response body.
             * @param result the #GAsyncResult passed to your callback
             * @returns a #GInputStream for reading the   response body, or %NULL on error.
             */
            send_finish(result: Gio.AsyncResult): Gio.InputStream;
            /**
             * Synchronously send `msg`. This call will not return until the
             * transfer is finished successfully or there is an unrecoverable
             * error.
             *
             * Unlike with soup_session_queue_message(), `msg` is not freed upon
             * return.
             *
             * (Note that if you call this method on a #SoupSessionAsync, it will
             * still use asynchronous I/O internally, running the glib main loop
             * to process the message, which may also cause other events to be
             * processed.)
             *
             * Contrast this method with soup_session_send(), which also
             * synchronously sends a message, but returns before reading the
             * response body, and allows you to read the response via a
             * #GInputStream.
             * @param msg the message to send
             * @returns the HTTP status code of the response
             */
            send_message(msg: Message): number;
            /**
             * "Steals" the HTTP connection associated with `msg` from `session`.
             * This happens immediately, regardless of the current state of the
             * connection, and `msg'`s callback will not be called. You can steal
             * the connection from a #SoupMessage signal handler if you need to
             * wait for part or all of the response to be received first.
             *
             * Calling this function may cause `msg` to be freed if you are not
             * holding any other reference to it.
             * @param msg the message whose connection is to be stolen
             * @returns the #GIOStream formerly associated   with @msg (or %NULL if @msg was no longer associated with a   connection). No guarantees are made about what kind of #GIOStream   is returned.
             */
            steal_connection(msg: Message): Gio.IOStream;
            /**
             * Resumes HTTP I/O on `msg`. Use this to resume after calling
             * soup_session_pause_message().
             *
             * If `msg` is being sent via blocking I/O, this will resume reading or
             * writing immediately. If `msg` is using non-blocking I/O, then
             * reading or writing won't resume until you return to the main loop.
             *
             * This may only be called for asynchronous messages (those sent on a
             * #SoupSessionAsync or using soup_session_queue_message()).
             * @param msg a #SoupMessage currently running on @session
             */
            unpause_message(msg: Message): void;
            /**
             * Asynchronously creates a #SoupWebsocketConnection to communicate
             * with a remote server.
             *
             * All necessary WebSocket-related headers will be added to `msg,` and
             * it will then be sent and asynchronously processed normally
             * (including handling of redirection and HTTP authentication).
             *
             * If the server returns "101 Switching Protocols", then `msg'`s status
             * code and response headers will be updated, and then the WebSocket
             * handshake will be completed. On success,
             * soup_session_websocket_connect_finish() will return a new
             * #SoupWebsocketConnection. On failure it will return a #GError.
             *
             * If the server returns a status other than "101 Switching
             * Protocols", then `msg` will contain the complete response headers
             * and body from the server's response, and
             * soup_session_websocket_connect_finish() will return
             * %SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET.
             * @param msg #SoupMessage indicating the WebSocket server to connect to
             * @param origin origin of the connection
             * @param protocols a   %NULL-terminated array of protocols supported
             * @param cancellable a #GCancellable
             */
            websocket_connect_async(
                msg: Message,
                origin?: string | null,
                protocols?: string[] | null,
                cancellable?: Gio.Cancellable | null,
            ): globalThis.Promise<WebsocketConnection>;
            /**
             * Asynchronously creates a #SoupWebsocketConnection to communicate
             * with a remote server.
             *
             * All necessary WebSocket-related headers will be added to `msg,` and
             * it will then be sent and asynchronously processed normally
             * (including handling of redirection and HTTP authentication).
             *
             * If the server returns "101 Switching Protocols", then `msg'`s status
             * code and response headers will be updated, and then the WebSocket
             * handshake will be completed. On success,
             * soup_session_websocket_connect_finish() will return a new
             * #SoupWebsocketConnection. On failure it will return a #GError.
             *
             * If the server returns a status other than "101 Switching
             * Protocols", then `msg` will contain the complete response headers
             * and body from the server's response, and
             * soup_session_websocket_connect_finish() will return
             * %SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET.
             * @param msg #SoupMessage indicating the WebSocket server to connect to
             * @param origin origin of the connection
             * @param protocols a   %NULL-terminated array of protocols supported
             * @param cancellable a #GCancellable
             * @param callback the callback to invoke
             */
            websocket_connect_async(
                msg: Message,
                origin: string | null,
                protocols: string[] | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously creates a #SoupWebsocketConnection to communicate
             * with a remote server.
             *
             * All necessary WebSocket-related headers will be added to `msg,` and
             * it will then be sent and asynchronously processed normally
             * (including handling of redirection and HTTP authentication).
             *
             * If the server returns "101 Switching Protocols", then `msg'`s status
             * code and response headers will be updated, and then the WebSocket
             * handshake will be completed. On success,
             * soup_session_websocket_connect_finish() will return a new
             * #SoupWebsocketConnection. On failure it will return a #GError.
             *
             * If the server returns a status other than "101 Switching
             * Protocols", then `msg` will contain the complete response headers
             * and body from the server's response, and
             * soup_session_websocket_connect_finish() will return
             * %SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET.
             * @param msg #SoupMessage indicating the WebSocket server to connect to
             * @param origin origin of the connection
             * @param protocols a   %NULL-terminated array of protocols supported
             * @param cancellable a #GCancellable
             * @param callback the callback to invoke
             */
            websocket_connect_async(
                msg: Message,
                origin?: string | null,
                protocols?: string[] | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): globalThis.Promise<WebsocketConnection> | void;
            /**
             * Gets the #SoupWebsocketConnection response to a
             * soup_session_websocket_connect_async() call and (if successful),
             * returns a #SoupWebsocketConnection that can be used to communicate
             * with the server.
             * @param result the #GAsyncResult passed to your callback
             * @returns a new #SoupWebsocketConnection, or   %NULL on error.
             */
            websocket_connect_finish(result: Gio.AsyncResult): WebsocketConnection;
            /**
             * Checks if `msg` contains a response that would cause `session` to
             * redirect it to a new URL (ignoring `msg'`s %SOUP_MESSAGE_NO_REDIRECT
             * flag, and the number of times it has already been redirected).
             * @param msg a #SoupMessage that has response headers
             * @returns whether @msg would be redirected
             */
            would_redirect(msg: Message): boolean;
        }

        namespace SessionAsync {
            // Signal signatures
            interface SignalSignatures extends Session.SignalSignatures {
                'notify::accept-language': (pspec: GObject.ParamSpec) => void;
                'notify::accept-language-auto': (pspec: GObject.ParamSpec) => void;
                'notify::async-context': (pspec: GObject.ParamSpec) => void;
                'notify::http-aliases': (pspec: GObject.ParamSpec) => void;
                'notify::https-aliases': (pspec: GObject.ParamSpec) => void;
                'notify::idle-timeout': (pspec: GObject.ParamSpec) => void;
                'notify::local-address': (pspec: GObject.ParamSpec) => void;
                'notify::max-conns': (pspec: GObject.ParamSpec) => void;
                'notify::max-conns-per-host': (pspec: GObject.ParamSpec) => void;
                'notify::proxy-resolver': (pspec: GObject.ParamSpec) => void;
                'notify::proxy-uri': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-ca-file': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-strict': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-use-system-ca-file': (pspec: GObject.ParamSpec) => void;
                'notify::timeout': (pspec: GObject.ParamSpec) => void;
                'notify::tls-database': (pspec: GObject.ParamSpec) => void;
                'notify::tls-interaction': (pspec: GObject.ParamSpec) => void;
                'notify::use-ntlm': (pspec: GObject.ParamSpec) => void;
                'notify::use-thread-context': (pspec: GObject.ParamSpec) => void;
                'notify::user-agent': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends Session.ConstructorProps {}
        }

        class SessionAsync extends Session {
            static $gtype: GObject.GType<SessionAsync>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: SessionAsync.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<SessionAsync.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): SessionAsync;

            // Signals

            connect<K extends keyof SessionAsync.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, SessionAsync.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof SessionAsync.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, SessionAsync.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof SessionAsync.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<SessionAsync.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;
        }

        namespace SessionSync {
            // Signal signatures
            interface SignalSignatures extends Session.SignalSignatures {
                'notify::accept-language': (pspec: GObject.ParamSpec) => void;
                'notify::accept-language-auto': (pspec: GObject.ParamSpec) => void;
                'notify::async-context': (pspec: GObject.ParamSpec) => void;
                'notify::http-aliases': (pspec: GObject.ParamSpec) => void;
                'notify::https-aliases': (pspec: GObject.ParamSpec) => void;
                'notify::idle-timeout': (pspec: GObject.ParamSpec) => void;
                'notify::local-address': (pspec: GObject.ParamSpec) => void;
                'notify::max-conns': (pspec: GObject.ParamSpec) => void;
                'notify::max-conns-per-host': (pspec: GObject.ParamSpec) => void;
                'notify::proxy-resolver': (pspec: GObject.ParamSpec) => void;
                'notify::proxy-uri': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-ca-file': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-strict': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-use-system-ca-file': (pspec: GObject.ParamSpec) => void;
                'notify::timeout': (pspec: GObject.ParamSpec) => void;
                'notify::tls-database': (pspec: GObject.ParamSpec) => void;
                'notify::tls-interaction': (pspec: GObject.ParamSpec) => void;
                'notify::use-ntlm': (pspec: GObject.ParamSpec) => void;
                'notify::use-thread-context': (pspec: GObject.ParamSpec) => void;
                'notify::user-agent': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends Session.ConstructorProps {}
        }

        class SessionSync extends Session {
            static $gtype: GObject.GType<SessionSync>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: SessionSync.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<SessionSync.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): SessionSync;

            // Signals

            connect<K extends keyof SessionSync.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, SessionSync.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof SessionSync.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, SessionSync.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof SessionSync.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<SessionSync.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;
        }

        namespace Socket {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                disconnected: () => void;
                event: (arg0: Gio.SocketClientEvent, arg1: Gio.IOStream) => void;
                'new-connection': (arg0: Socket) => void;
                readable: () => void;
                writable: () => void;
                'notify::async-context': (pspec: GObject.ParamSpec) => void;
                'notify::fd': (pspec: GObject.ParamSpec) => void;
                'notify::gsocket': (pspec: GObject.ParamSpec) => void;
                'notify::iostream': (pspec: GObject.ParamSpec) => void;
                'notify::ipv6-only': (pspec: GObject.ParamSpec) => void;
                'notify::is-server': (pspec: GObject.ParamSpec) => void;
                'notify::local-address': (pspec: GObject.ParamSpec) => void;
                'notify::non-blocking': (pspec: GObject.ParamSpec) => void;
                'notify::remote-address': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-creds': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-fallback': (pspec: GObject.ParamSpec) => void;
                'notify::ssl-strict': (pspec: GObject.ParamSpec) => void;
                'notify::timeout': (pspec: GObject.ParamSpec) => void;
                'notify::tls-certificate': (pspec: GObject.ParamSpec) => void;
                'notify::tls-errors': (pspec: GObject.ParamSpec) => void;
                'notify::trusted-certificate': (pspec: GObject.ParamSpec) => void;
                'notify::use-thread-context': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, Gio.Initable.ConstructorProps {
                async_context: any;
                asyncContext: any;
                fd: number;
                gsocket: Gio.Socket;
                iostream: Gio.IOStream;
                ipv6_only: boolean;
                ipv6Only: boolean;
                is_server: boolean;
                isServer: boolean;
                local_address: Address;
                localAddress: Address;
                non_blocking: boolean;
                nonBlocking: boolean;
                remote_address: Address;
                remoteAddress: Address;
                ssl_creds: any;
                sslCreds: any;
                ssl_fallback: boolean;
                sslFallback: boolean;
                ssl_strict: boolean;
                sslStrict: boolean;
                timeout: number;
                tls_certificate: Gio.TlsCertificate;
                tlsCertificate: Gio.TlsCertificate;
                tls_errors: Gio.TlsCertificateFlags;
                tlsErrors: Gio.TlsCertificateFlags;
                trusted_certificate: boolean;
                trustedCertificate: boolean;
                use_thread_context: boolean;
                useThreadContext: boolean;
            }
        }

        class Socket extends GObject.Object implements Gio.Initable {
            static $gtype: GObject.GType<Socket>;

            // Properties

            get async_context(): any;
            get asyncContext(): any;
            get fd(): number;
            set gsocket(val: Gio.Socket);
            set iostream(val: Gio.IOStream);
            get ipv6_only(): boolean;
            set ipv6_only(val: boolean);
            get ipv6Only(): boolean;
            set ipv6Only(val: boolean);
            /**
             * Whether or not the socket is a server socket.
             *
             * Note that for "ordinary" #SoupSockets this will be set for
             * both listening sockets and the sockets emitted by
             * #SoupSocket::new-connection, but for sockets created by
             * setting #SoupSocket:fd, it will only be set for listening
             * sockets.
             */
            get is_server(): boolean;
            /**
             * Whether or not the socket is a server socket.
             *
             * Note that for "ordinary" #SoupSockets this will be set for
             * both listening sockets and the sockets emitted by
             * #SoupSocket::new-connection, but for sockets created by
             * setting #SoupSocket:fd, it will only be set for listening
             * sockets.
             */
            get isServer(): boolean;
            get local_address(): Address;
            get localAddress(): Address;
            /**
             * Whether or not the socket uses non-blocking I/O.
             *
             * #SoupSocket's I/O methods are designed around the idea of
             * using a single codepath for both synchronous and
             * asynchronous I/O. If you want to read off a #SoupSocket,
             * the "correct" way to do it is to call soup_socket_read() or
             * soup_socket_read_until() repeatedly until you have read
             * everything you want. If it returns %SOUP_SOCKET_WOULD_BLOCK
             * at any point, stop reading and wait for it to emit the
             * #SoupSocket::readable signal. Then go back to the
             * reading-as-much-as-you-can loop. Likewise, for writing to a
             * #SoupSocket, you should call soup_socket_write() either
             * until you have written everything, or it returns
             * %SOUP_SOCKET_WOULD_BLOCK (in which case you wait for
             * #SoupSocket::writable and then go back into the loop).
             *
             * Code written this way will work correctly with both
             * blocking and non-blocking sockets; blocking sockets will
             * simply never return %SOUP_SOCKET_WOULD_BLOCK, and so the
             * code that handles that case just won't get used for them.
             */
            get non_blocking(): boolean;
            set non_blocking(val: boolean);
            /**
             * Whether or not the socket uses non-blocking I/O.
             *
             * #SoupSocket's I/O methods are designed around the idea of
             * using a single codepath for both synchronous and
             * asynchronous I/O. If you want to read off a #SoupSocket,
             * the "correct" way to do it is to call soup_socket_read() or
             * soup_socket_read_until() repeatedly until you have read
             * everything you want. If it returns %SOUP_SOCKET_WOULD_BLOCK
             * at any point, stop reading and wait for it to emit the
             * #SoupSocket::readable signal. Then go back to the
             * reading-as-much-as-you-can loop. Likewise, for writing to a
             * #SoupSocket, you should call soup_socket_write() either
             * until you have written everything, or it returns
             * %SOUP_SOCKET_WOULD_BLOCK (in which case you wait for
             * #SoupSocket::writable and then go back into the loop).
             *
             * Code written this way will work correctly with both
             * blocking and non-blocking sockets; blocking sockets will
             * simply never return %SOUP_SOCKET_WOULD_BLOCK, and so the
             * code that handles that case just won't get used for them.
             */
            get nonBlocking(): boolean;
            set nonBlocking(val: boolean);
            get remote_address(): Address;
            get remoteAddress(): Address;
            get ssl_creds(): any;
            set ssl_creds(val: any);
            get sslCreds(): any;
            set sslCreds(val: any);
            get ssl_fallback(): boolean;
            get sslFallback(): boolean;
            get ssl_strict(): boolean;
            get sslStrict(): boolean;
            get timeout(): number;
            set timeout(val: number);
            get tls_certificate(): Gio.TlsCertificate;
            get tlsCertificate(): Gio.TlsCertificate;
            get tls_errors(): Gio.TlsCertificateFlags;
            get tlsErrors(): Gio.TlsCertificateFlags;
            get trusted_certificate(): boolean;
            get trustedCertificate(): boolean;
            /**
             * Use g_main_context_get_thread_default().
             */
            get use_thread_context(): boolean;
            /**
             * Use g_main_context_get_thread_default().
             */
            get useThreadContext(): boolean;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: Socket.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<Socket.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof Socket.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Socket.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof Socket.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, Socket.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof Socket.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<Socket.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            vfunc_disconnected(): void;
            vfunc_new_connection(new_sock: Socket): void;
            vfunc_readable(): void;
            vfunc_writable(): void;

            // Methods

            /**
             * Begins asynchronously connecting to `sock'`s remote address. The
             * socket will call `callback` when it succeeds or fails (but not
             * before returning from this function).
             *
             * If `cancellable` is non-%NULL, it can be used to cancel the
             * connection. `callback` will still be invoked in this case, with a
             * status of %SOUP_STATUS_CANCELLED.
             * @param cancellable a #GCancellable, or %NULL
             * @param callback callback to call after connecting
             */
            connect_async(cancellable: Gio.Cancellable | null, callback: SocketCallback): void;
            /**
             * Attempt to synchronously connect `sock` to its remote address.
             *
             * If `cancellable` is non-%NULL, it can be used to cancel the
             * connection, in which case soup_socket_connect_sync() will return
             * %SOUP_STATUS_CANCELLED.
             * @param cancellable a #GCancellable, or %NULL
             * @returns a success or failure code.
             */
            connect_sync(cancellable?: Gio.Cancellable | null): number;
            /**
             * Disconnects `sock`. Any further read or write attempts on it will
             * fail.
             */
            disconnect(): void;
            /**
             * Gets `sock'`s underlying file descriptor.
             *
             * Note that fiddling with the file descriptor may break the
             * #SoupSocket.
             * @returns @sock's file descriptor.
             */
            get_fd(): number;
            /**
             * Returns the #SoupAddress corresponding to the local end of `sock`.
             *
             * Calling this method on an unconnected socket is considered to be
             * an error, and produces undefined results.
             * @returns the #SoupAddress
             */
            get_local_address(): Address;
            /**
             * Returns the #SoupAddress corresponding to the remote end of `sock`.
             *
             * Calling this method on an unconnected socket is considered to be
             * an error, and produces undefined results.
             * @returns the #SoupAddress
             */
            get_remote_address(): Address;
            /**
             * Tests if `sock` is connected to another host
             * @returns %TRUE or %FALSE.
             */
            is_connected(): boolean;
            /**
             * Tests if `sock` is doing (or has attempted to do) SSL.
             * @returns %TRUE if @sock has SSL credentials set
             */
            is_ssl(): boolean;
            /**
             * Makes `sock` start listening on its local address. When connections
             * come in, `sock` will emit #SoupSocket::new_connection.
             * @returns whether or not @sock is now listening.
             */
            listen(): boolean;
            /**
             * Attempts to read up to `len` bytes from `sock` into `buffer`. If some
             * data is successfully read, soup_socket_read() will return
             * %SOUP_SOCKET_OK, and *`nread` will contain the number of bytes
             * actually read (which may be less than `len)`.
             *
             * If `sock` is non-blocking, and no data is available, the return
             * value will be %SOUP_SOCKET_WOULD_BLOCK. In this case, the caller
             * can connect to the #SoupSocket::readable signal to know when there
             * is more data to read. (NB: You MUST read all available data off the
             * socket first. #SoupSocket::readable is only emitted after
             * soup_socket_read() returns %SOUP_SOCKET_WOULD_BLOCK, and it is only
             * emitted once. See the documentation for #SoupSocket:non-blocking.)
             * @param buffer buffer to read   into
             * @param cancellable a #GCancellable, or %NULL
             * @returns a #SoupSocketIOStatus, as described above (or %SOUP_SOCKET_EOF if the socket is no longer connected, or %SOUP_SOCKET_ERROR on any other error, in which case @error will also be set).
             */
            read(buffer: Uint8Array | string, cancellable?: Gio.Cancellable | null): [SocketIOStatus, number];
            /**
             * Like soup_socket_read(), but reads no further than the first
             * occurrence of `boundary`. (If the boundary is found, it will be
             * included in the returned data, and *`got_boundary` will be set to
             * %TRUE.) Any data after the boundary will returned in future reads.
             *
             * soup_socket_read_until() will almost always return fewer than `len`
             * bytes: if the boundary is found, then it will only return the bytes
             * up until the end of the boundary, and if the boundary is not found,
             * then it will leave the last <literal>(boundary_len - 1)</literal>
             * bytes in its internal buffer, in case they form the start of the
             * boundary string. Thus, `len` normally needs to be at least 1 byte
             * longer than `boundary_len` if you want to make any progress at all.
             * @param buffer buffer to read   into
             * @param boundary boundary to read until
             * @param boundary_len length of @boundary in bytes
             * @param cancellable a #GCancellable, or %NULL
             * @returns as for soup_socket_read()
             */
            read_until(
                buffer: Uint8Array | string,
                boundary: any | null,
                boundary_len: number,
                cancellable?: Gio.Cancellable | null,
            ): [SocketIOStatus, number, boolean];
            /**
             * Starts using SSL on `socket,` expecting to find a host named
             * `ssl_host`.
             * @param ssl_host hostname of the SSL server
             * @param cancellable a #GCancellable
             * @returns success or failure
             */
            start_proxy_ssl(ssl_host: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Starts using SSL on `socket`.
             * @param cancellable a #GCancellable
             * @returns success or failure
             */
            start_ssl(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Attempts to write `len` bytes from `buffer` to `sock`. If some data is
             * successfully written, the return status will be %SOUP_SOCKET_OK,
             * and *`nwrote` will contain the number of bytes actually written
             * (which may be less than `len)`.
             *
             * If `sock` is non-blocking, and no data could be written right away,
             * the return value will be %SOUP_SOCKET_WOULD_BLOCK. In this case,
             * the caller can connect to the #SoupSocket::writable signal to know
             * when more data can be written. (NB: #SoupSocket::writable is only
             * emitted after soup_socket_write() returns %SOUP_SOCKET_WOULD_BLOCK,
             * and it is only emitted once. See the documentation for
             * #SoupSocket:non-blocking.)
             * @param buffer data to write
             * @param cancellable a #GCancellable, or %NULL
             * @returns a #SoupSocketIOStatus, as described above (or %SOUP_SOCKET_EOF or %SOUP_SOCKET_ERROR. @error will be set if the return value is %SOUP_SOCKET_ERROR.)
             */
            write(buffer: Uint8Array | string, cancellable?: Gio.Cancellable | null): [SocketIOStatus, number];

            // Inherited methods
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace WebsocketConnection {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {
                closed: () => void;
                closing: () => void;
                error: (arg0: GLib.Error) => void;
                message: (arg0: number, arg1: GLib.Bytes) => void;
                pong: (arg0: GLib.Bytes) => void;
                'notify::connection-type': (pspec: GObject.ParamSpec) => void;
                'notify::extensions': (pspec: GObject.ParamSpec) => void;
                'notify::io-stream': (pspec: GObject.ParamSpec) => void;
                'notify::keepalive-interval': (pspec: GObject.ParamSpec) => void;
                'notify::max-incoming-payload-size': (pspec: GObject.ParamSpec) => void;
                'notify::origin': (pspec: GObject.ParamSpec) => void;
                'notify::protocol': (pspec: GObject.ParamSpec) => void;
                'notify::state': (pspec: GObject.ParamSpec) => void;
                'notify::uri': (pspec: GObject.ParamSpec) => void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                connection_type: WebsocketConnectionType;
                connectionType: WebsocketConnectionType;
                extensions: any;
                io_stream: Gio.IOStream;
                ioStream: Gio.IOStream;
                keepalive_interval: number;
                keepaliveInterval: number;
                max_incoming_payload_size: number;
                maxIncomingPayloadSize: number;
                origin: string;
                protocol: string;
                state: WebsocketState;
                uri: URI;
            }
        }

        /**
         * A class representing a WebSocket connection.
         */
        class WebsocketConnection extends GObject.Object {
            static $gtype: GObject.GType<WebsocketConnection>;

            // Properties

            /**
             * The type of connection (client/server).
             */
            get connection_type(): WebsocketConnectionType;
            /**
             * The type of connection (client/server).
             */
            get connectionType(): WebsocketConnectionType;
            /**
             * List of #SoupWebsocketExtension objects that are active in the connection.
             */
            get extensions(): any;
            /**
             * The underlying IO stream the WebSocket is communicating
             * over.
             *
             * The input and output streams must be pollable streams.
             */
            get io_stream(): Gio.IOStream;
            /**
             * The underlying IO stream the WebSocket is communicating
             * over.
             *
             * The input and output streams must be pollable streams.
             */
            get ioStream(): Gio.IOStream;
            /**
             * Interval in seconds on when to send a ping message which will
             * serve as a keepalive message. If set to 0 the keepalive message is
             * disabled.
             */
            get keepalive_interval(): number;
            set keepalive_interval(val: number);
            /**
             * Interval in seconds on when to send a ping message which will
             * serve as a keepalive message. If set to 0 the keepalive message is
             * disabled.
             */
            get keepaliveInterval(): number;
            set keepaliveInterval(val: number);
            /**
             * The maximum payload size for incoming packets the protocol expects
             * or 0 to not limit it.
             */
            get max_incoming_payload_size(): number;
            set max_incoming_payload_size(val: number);
            /**
             * The maximum payload size for incoming packets the protocol expects
             * or 0 to not limit it.
             */
            get maxIncomingPayloadSize(): number;
            set maxIncomingPayloadSize(val: number);
            /**
             * The client's Origin.
             */
            get origin(): string;
            /**
             * The chosen protocol, or %NULL if a protocol was not agreed
             * upon.
             */
            get protocol(): string;
            /**
             * The current state of the WebSocket.
             */
            get state(): WebsocketState;
            /**
             * The URI of the WebSocket.
             *
             * For servers this represents the address of the WebSocket,
             * and for clients it is the address connected to.
             */
            get uri(): URI;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: WebsocketConnection.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<WebsocketConnection.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](
                stream: Gio.IOStream,
                uri: URI,
                type: WebsocketConnectionType,
                origin?: string | null,
                protocol?: string | null,
            ): WebsocketConnection;

            static new_with_extensions(
                stream: Gio.IOStream,
                uri: URI,
                type: WebsocketConnectionType,
                origin: string | null,
                protocol: string | null,
                extensions: WebsocketExtension[],
            ): WebsocketConnection;

            // Signals

            connect<K extends keyof WebsocketConnection.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, WebsocketConnection.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof WebsocketConnection.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, WebsocketConnection.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof WebsocketConnection.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<WebsocketConnection.SignalSignatures[K]> extends [any, ...infer Q]
                    ? Q
                    : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            /**
             * default handler for the #SoupWebsocketConnection::closed signal
             */
            vfunc_closed(): void;
            /**
             * the default handler for the #SoupWebsocketConnection:closing signal
             */
            vfunc_closing(): void;
            /**
             * default handler for the #SoupWebsocketConnection::error signal
             * @param error
             */
            vfunc_error(error: GLib.Error): void;
            /**
             * default handler for the #SoupWebsocketConnection::message signal
             * @param type
             * @param message
             */
            vfunc_message(type: WebsocketDataType, message: GLib.Bytes | Uint8Array): void;
            /**
             * default handler for the #SoupWebsocketConnection::pong signal
             * @param message
             */
            vfunc_pong(message: GLib.Bytes | Uint8Array): void;

            // Methods

            /**
             * Close the connection in an orderly fashion.
             *
             * Note that until the #SoupWebsocketConnection::closed signal fires, the connection
             * is not yet completely closed. The close message is not even sent until the
             * main loop runs.
             *
             * The `code` and `data` are sent to the peer along with the close request.
             * If `code` is %SOUP_WEBSOCKET_CLOSE_NO_STATUS a close message with no body
             * (without code and data) is sent.
             * Note that the `data` must be UTF-8 valid.
             * @param code close code
             * @param data close data
             */
            close(code: number, data?: string | null): void;
            /**
             * Get the close code received from the WebSocket peer.
             *
             * This only becomes valid once the WebSocket is in the
             * %SOUP_WEBSOCKET_STATE_CLOSED state. The value will often be in the
             * #SoupWebsocketCloseCode enumeration, but may also be an application
             * defined close code.
             * @returns the close code or zero.
             */
            get_close_code(): number;
            /**
             * Get the close data received from the WebSocket peer.
             *
             * This only becomes valid once the WebSocket is in the
             * %SOUP_WEBSOCKET_STATE_CLOSED state. The data may be freed once
             * the main loop is run, so copy it if you need to keep it around.
             * @returns the close data or %NULL
             */
            get_close_data(): string;
            /**
             * Get the connection type (client/server) of the connection.
             * @returns the connection type
             */
            get_connection_type(): WebsocketConnectionType;
            /**
             * Get the extensions chosen via negotiation with the peer.
             * @returns a #GList of #SoupWebsocketExtension objects
             */
            get_extensions(): WebsocketExtension[];
            /**
             * Get the I/O stream the WebSocket is communicating over.
             * @returns the WebSocket's I/O stream.
             */
            get_io_stream(): Gio.IOStream;
            /**
             * Gets the keepalive interval in seconds or 0 if disabled.
             * @returns the keepalive interval.
             */
            get_keepalive_interval(): number;
            /**
             * Gets the maximum payload size allowed for incoming packets.
             * @returns the maximum payload size.
             */
            get_max_incoming_payload_size(): number;
            /**
             * Get the origin of the WebSocket.
             * @returns the origin, or %NULL
             */
            get_origin(): string | null;
            /**
             * Get the protocol chosen via negotiation with the peer.
             * @returns the chosen protocol, or %NULL
             */
            get_protocol(): string | null;
            /**
             * Get the current state of the WebSocket.
             * @returns the state
             */
            get_state(): WebsocketState;
            /**
             * Get the URI of the WebSocket.
             *
             * For servers this represents the address of the WebSocket, and
             * for clients it is the address connected to.
             * @returns the URI
             */
            get_uri(): URI;
            /**
             * Send a binary message to the peer. If `length` is 0, `data` may be %NULL.
             *
             * The message is queued to be sent and will be sent when the main loop
             * is run.
             * @param data the message contents
             */
            send_binary(data?: Uint8Array | null): void;
            /**
             * Send a message of the given `type` to the peer. Note that this method,
             * allows to send text messages containing %NULL characters.
             *
             * The message is queued to be sent and will be sent when the main loop
             * is run.
             * @param type the type of message contents
             * @param message the message data as #GBytes
             */
            send_message(type: WebsocketDataType | null, message: GLib.Bytes | Uint8Array): void;
            /**
             * Send a %NULL-terminated text (UTF-8) message to the peer. If you need
             * to send text messages containing %NULL characters use
             * soup_websocket_connection_send_message() instead.
             *
             * The message is queued to be sent and will be sent when the main loop
             * is run.
             * @param text the message contents
             */
            send_text(text: string): void;
            /**
             * Sets the interval in seconds on when to send a ping message which will serve
             * as a keepalive message. If set to 0 the keepalive message is disabled.
             * @param interval the interval to send a ping message or 0 to disable it
             */
            set_keepalive_interval(interval: number): void;
            /**
             * Sets the maximum payload size allowed for incoming packets. It
             * does not limit the outgoing packet size.
             * @param max_incoming_payload_size the maximum payload size
             */
            set_max_incoming_payload_size(max_incoming_payload_size: number): void;
        }

        namespace WebsocketExtension {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {}

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        abstract class WebsocketExtension extends GObject.Object {
            static $gtype: GObject.GType<WebsocketExtension>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: WebsocketExtension.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<WebsocketExtension.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof WebsocketExtension.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, WebsocketExtension.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof WebsocketExtension.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, WebsocketExtension.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof WebsocketExtension.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<WebsocketExtension.SignalSignatures[K]> extends [any, ...infer Q]
                    ? Q
                    : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Virtual methods

            /**
             * Configures `extension` with the given `params`
             * @param connection_type either %SOUP_WEBSOCKET_CONNECTION_CLIENT or %SOUP_WEBSOCKET_CONNECTION_SERVER
             * @param params the parameters, or %NULL
             */
            vfunc_configure(
                connection_type: WebsocketConnectionType,
                params?: GLib.HashTable<any, any> | null,
            ): boolean;
            /**
             * Get the parameters strings to be included in the request header. If the extension
             * doesn't include any parameter in the request, this function returns %NULL.
             */
            vfunc_get_request_params(): string | null;
            /**
             * Get the parameters strings to be included in the response header. If the extension
             * doesn't include any parameter in the response, this function returns %NULL.
             */
            vfunc_get_response_params(): string | null;
            /**
             * Process a message after it's received. If the payload isn't changed the given
             * `payload` is just returned, otherwise g_bytes_unref() is called on the given
             * `payload` and a new #GBytes is returned with the new data.
             *
             * Extensions using reserved bits of the header will reset them in `header`.
             * @param header the message header
             * @param payload the payload data
             */
            vfunc_process_incoming_message(header: number, payload: GLib.Bytes | Uint8Array): [GLib.Bytes, number];
            /**
             * Process a message before it's sent. If the payload isn't changed the given
             * `payload` is just returned, otherwise g_bytes_unref() is called on the given
             * `payload` and a new #GBytes is returned with the new data.
             *
             * Extensions using reserved bits of the header will change them in `header`.
             * @param header the message header
             * @param payload the payload data
             */
            vfunc_process_outgoing_message(header: number, payload: GLib.Bytes | Uint8Array): [GLib.Bytes, number];

            // Methods

            /**
             * Configures `extension` with the given `params`
             * @param connection_type either %SOUP_WEBSOCKET_CONNECTION_CLIENT or %SOUP_WEBSOCKET_CONNECTION_SERVER
             * @param params the parameters, or %NULL
             * @returns %TRUE if extension could be configured with the given parameters, or %FALSE otherwise
             */
            configure(
                connection_type: WebsocketConnectionType | null,
                params?: GLib.HashTable<any, any> | null,
            ): boolean;
            /**
             * Get the parameters strings to be included in the request header. If the extension
             * doesn't include any parameter in the request, this function returns %NULL.
             * @returns a new allocated string with the parameters
             */
            get_request_params(): string | null;
            /**
             * Get the parameters strings to be included in the response header. If the extension
             * doesn't include any parameter in the response, this function returns %NULL.
             * @returns a new allocated string with the parameters
             */
            get_response_params(): string | null;
            /**
             * Process a message after it's received. If the payload isn't changed the given
             * `payload` is just returned, otherwise g_bytes_unref() is called on the given
             * `payload` and a new #GBytes is returned with the new data.
             *
             * Extensions using reserved bits of the header will reset them in `header`.
             * @param header the message header
             * @param payload the payload data
             * @returns the message payload data, or %NULL in case of error
             */
            process_incoming_message(header: number, payload: GLib.Bytes | Uint8Array): [GLib.Bytes, number];
            /**
             * Process a message before it's sent. If the payload isn't changed the given
             * `payload` is just returned, otherwise g_bytes_unref() is called on the given
             * `payload` and a new #GBytes is returned with the new data.
             *
             * Extensions using reserved bits of the header will change them in `header`.
             * @param header the message header
             * @param payload the payload data
             * @returns the message payload data, or %NULL in case of error
             */
            process_outgoing_message(header: number, payload: GLib.Bytes | Uint8Array): [GLib.Bytes, number];
        }

        namespace WebsocketExtensionDeflate {
            // Signal signatures
            interface SignalSignatures extends WebsocketExtension.SignalSignatures {}

            // Constructor properties interface

            interface ConstructorProps extends WebsocketExtension.ConstructorProps {}
        }

        class WebsocketExtensionDeflate extends WebsocketExtension {
            static $gtype: GObject.GType<WebsocketExtensionDeflate>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: WebsocketExtensionDeflate.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<WebsocketExtensionDeflate.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof WebsocketExtensionDeflate.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, WebsocketExtensionDeflate.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof WebsocketExtensionDeflate.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, WebsocketExtensionDeflate.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof WebsocketExtensionDeflate.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<WebsocketExtensionDeflate.SignalSignatures[K]> extends [any, ...infer Q]
                    ? Q
                    : never
            ): void;
            emit(signal: string, ...args: any[]): void;
        }

        namespace WebsocketExtensionManager {
            // Signal signatures
            interface SignalSignatures extends GObject.Object.SignalSignatures {}

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, SessionFeature.ConstructorProps {}
        }

        class WebsocketExtensionManager extends GObject.Object implements SessionFeature {
            static $gtype: GObject.GType<WebsocketExtensionManager>;

            /**
             * Compile-time signal type information.
             *
             * This instance property is generated only for TypeScript type checking.
             * It is not defined at runtime and should not be accessed in JS code.
             * @internal
             */
            $signals: WebsocketExtensionManager.SignalSignatures;

            // Constructors

            constructor(properties?: Partial<WebsocketExtensionManager.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect<K extends keyof WebsocketExtensionManager.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, WebsocketExtensionManager.SignalSignatures[K]>,
            ): number;
            connect(signal: string, callback: (...args: any[]) => any): number;
            connect_after<K extends keyof WebsocketExtensionManager.SignalSignatures>(
                signal: K,
                callback: GObject.SignalCallback<this, WebsocketExtensionManager.SignalSignatures[K]>,
            ): number;
            connect_after(signal: string, callback: (...args: any[]) => any): number;
            emit<K extends keyof WebsocketExtensionManager.SignalSignatures>(
                signal: K,
                ...args: GObject.GjsParameters<WebsocketExtensionManager.SignalSignatures[K]> extends [any, ...infer Q]
                    ? Q
                    : never
            ): void;
            emit(signal: string, ...args: any[]): void;

            // Inherited methods
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             */
            vfunc_add_feature(type: GObject.GType): boolean;
            /**
             * Perform setup when a feature is added to a session
             * @param session
             */
            vfunc_attach(session: Session): void;
            /**
             * Perform cleanup when a feature is removed from a session
             * @param session
             */
            vfunc_detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             */
            vfunc_remove_feature(type: GObject.GType): boolean;
            /**
             * Proxies the session's #SoupSession::request_queued signal
             * @param session
             * @param msg
             */
            vfunc_request_queued(session: Session, msg: Message): void;
            /**
             * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
             * @param session
             * @param msg
             * @param socket
             */
            vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
            /**
             * Proxies the session's #SoupSession::request_unqueued signal
             * @param session
             * @param msg
             */
            vfunc_request_unqueued(session: Session, msg: Message): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        type AddressClass = typeof Address;
        type AuthClass = typeof Auth;
        type AuthDomainBasicClass = typeof AuthDomainBasic;
        type AuthDomainClass = typeof AuthDomain;
        type AuthDomainDigestClass = typeof AuthDomainDigest;
        type AuthManagerClass = typeof AuthManager;
        abstract class AuthManagerPrivate {
            static $gtype: GObject.GType<AuthManagerPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        /**
         * A data buffer, generally used to represent a chunk of a
         * #SoupMessageBody.
         *
         * `data` is a #char because that's generally convenient; in some
         * situations you may need to cast it to #guchar or another type.
         */
        class Buffer {
            static $gtype: GObject.GType<Buffer>;

            // Fields

            data: any;
            length: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    data: any;
                    length: number;
                }>,
            );
            _init(...args: any[]): void;

            static ['new'](use: MemoryUse, data: Uint8Array | string): Buffer;

            static ['new'](data: Uint8Array | string): Buffer;

            static new_with_owner(
                data: Uint8Array | string,
                owner?: any | null,
                owner_dnotify?: GLib.DestroyNotify | null,
            ): Buffer;

            // Methods

            /**
             * Makes a copy of `buffer`. In reality, #SoupBuffer is a refcounted
             * type, and calling soup_buffer_copy() will normally just increment
             * the refcount on `buffer` and return it. However, if `buffer` was
             * created with #SOUP_MEMORY_TEMPORARY memory, then soup_buffer_copy()
             * will actually return a copy of it, so that the data in the copy
             * will remain valid after the temporary buffer is freed.
             * @returns the new (or newly-reffed) buffer
             */
            copy(): Buffer;
            /**
             * Frees `buffer`. (In reality, as described in the documentation for
             * soup_buffer_copy(), this is actually an "unref" operation, and may
             * or may not actually free `buffer`.)
             */
            free(): void;
            /**
             * Creates a #GBytes pointing to the same memory as `buffer`. The
             * #GBytes will hold a reference on `buffer` to ensure that it is not
             * freed while the #GBytes is still valid.
             * @returns a new #GBytes which has the same content as the #SoupBuffer.
             */
            get_as_bytes(): GLib.Bytes;
            /**
             * This function exists for use by language bindings, because it's not
             * currently possible to get the right effect by annotating the fields
             * of #SoupBuffer.
             */
            get_data(): Uint8Array;
            /**
             * Gets the "owner" object for a buffer created with
             * soup_buffer_new_with_owner().
             * @returns the owner pointer
             */
            get_owner(): any | null;
            /**
             * Creates a new #SoupBuffer containing `length` bytes "copied" from
             * `parent` starting at `offset`. (Normally this will not actually copy
             * any data, but will instead simply reference the same data as
             * `parent` does.)
             * @param offset offset within @parent to start at
             * @param length number of bytes to copy from @parent
             * @returns the new #SoupBuffer.
             */
            new_subbuffer(offset: number, length: number): Buffer;
        }

        type CacheClass = typeof Cache;
        abstract class CachePrivate {
            static $gtype: GObject.GType<CachePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        /**
         * A #SoupClientContext provides additional information about the
         * client making a particular request. In particular, you can use
         * soup_client_context_get_auth_domain() and
         * soup_client_context_get_auth_user() to determine if HTTP
         * authentication was used successfully.
         *
         * soup_client_context_get_remote_address() and/or
         * soup_client_context_get_host() can be used to get information for
         * logging or debugging purposes. soup_client_context_get_gsocket() may
         * also be of use in some situations (eg, tracking when multiple
         * requests are made on the same connection).
         */
        abstract class ClientContext {
            static $gtype: GObject.GType<ClientContext>;

            // Constructors

            _init(...args: any[]): void;

            // Methods

            /**
             * Retrieves the #SoupAddress associated with the remote end
             * of a connection.
             * @returns the #SoupAddress associated with the remote end of a connection, it may be %NULL if you used soup_server_accept_iostream().
             */
            get_address(): Address | null;
            /**
             * Checks whether the request associated with `client` has been
             * authenticated, and if so returns the #SoupAuthDomain that
             * authenticated it.
             * @returns a #SoupAuthDomain, or %NULL if the request was not authenticated.
             */
            get_auth_domain(): AuthDomain | null;
            /**
             * Checks whether the request associated with `client` has been
             * authenticated, and if so returns the username that the client
             * authenticated as.
             * @returns the authenticated-as user, or %NULL if the request was not authenticated.
             */
            get_auth_user(): string | null;
            /**
             * Retrieves the #GSocket that `client` is associated with.
             *
             * If you are using this method to observe when multiple requests are
             * made on the same persistent HTTP connection (eg, as the ntlm-test
             * test program does), you will need to pay attention to socket
             * destruction as well (eg, by using weak references), so that you do
             * not get fooled when the allocator reuses the memory address of a
             * previously-destroyed socket to represent a new socket.
             * @returns the #GSocket that @client is associated with, %NULL if you used soup_server_accept_iostream().
             */
            get_gsocket(): Gio.Socket | null;
            /**
             * Retrieves the IP address associated with the remote end of a
             * connection.
             * @returns the IP address associated with the remote end of a connection, it may be %NULL if you used soup_server_accept_iostream().
             */
            get_host(): string | null;
            /**
             * Retrieves the #GSocketAddress associated with the local end
             * of a connection.
             * @returns the #GSocketAddress associated with the local end of a connection, it may be %NULL if you used soup_server_accept_iostream().
             */
            get_local_address(): Gio.SocketAddress | null;
            /**
             * Retrieves the #GSocketAddress associated with the remote end
             * of a connection.
             * @returns the #GSocketAddress associated with the remote end of a connection, it may be %NULL if you used soup_server_accept_iostream().
             */
            get_remote_address(): Gio.SocketAddress | null;
            /**
             * Retrieves the #SoupSocket that `client` is associated with.
             *
             * If you are using this method to observe when multiple requests are
             * made on the same persistent HTTP connection (eg, as the ntlm-test
             * test program does), you will need to pay attention to socket
             * destruction as well (either by using weak references, or by
             * connecting to the #SoupSocket::disconnected signal), so that you do
             * not get fooled when the allocator reuses the memory address of a
             * previously-destroyed socket to represent a new socket.
             * @returns the #SoupSocket that @client is associated with.
             */
            get_socket(): Socket;
            /**
             * "Steals" the HTTP connection associated with `client` from its
             * #SoupServer. This happens immediately, regardless of the current
             * state of the connection; if the response to the current
             * #SoupMessage has not yet finished being sent, then it will be
             * discarded; you can steal the connection from a
             * #SoupMessage:wrote-informational or #SoupMessage:wrote-body signal
             * handler if you need to wait for part or all of the response to be
             * sent.
             *
             * Note that when calling this function from C, `client` will most
             * likely be freed as a side effect.
             * @returns the #GIOStream formerly associated   with @client (or %NULL if @client was no longer associated with a   connection). No guarantees are made about what kind of #GIOStream   is returned.
             */
            steal_connection(): Gio.IOStream;
        }

        abstract class Connection {
            static $gtype: GObject.GType<Connection>;

            // Constructors

            _init(...args: any[]): void;
        }

        type ContentDecoderClass = typeof ContentDecoder;
        abstract class ContentDecoderPrivate {
            static $gtype: GObject.GType<ContentDecoderPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type ContentSnifferClass = typeof ContentSniffer;
        abstract class ContentSnifferPrivate {
            static $gtype: GObject.GType<ContentSnifferPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        /**
         * An HTTP cookie.
         *
         * `name` and `value` will be set for all cookies. If the cookie is
         * generated from a string that appears to have no name, then `name`
         * will be the empty string.
         *
         * `domain` and `path` give the host or domain, and path within that
         * host/domain, to restrict this cookie to. If `domain` starts with
         * ".", that indicates a domain (which matches the string after the
         * ".", or any hostname that has `domain` as a suffix). Otherwise, it
         * is a hostname and must match exactly.
         *
         * `expires` will be non-%NULL if the cookie uses either the original
         * "expires" attribute, or the newer "max-age" attribute. If `expires`
         * is %NULL, it indicates that neither "expires" nor "max-age" was
         * specified, and the cookie expires at the end of the session.
         *
         * If `http_only` is set, the cookie should not be exposed to untrusted
         * code (eg, javascript), so as to minimize the danger posed by
         * cross-site scripting attacks.
         */
        class Cookie {
            static $gtype: GObject.GType<Cookie>;

            // Fields

            name: string;
            value: string;
            domain: string;
            path: string;
            expires: Date;
            secure: boolean;
            http_only: boolean;

            // Constructors

            constructor(
                properties?: Partial<{
                    name: string;
                    value: string;
                    domain: string;
                    path: string;
                    secure: boolean;
                    http_only: boolean;
                }>,
            );
            _init(...args: any[]): void;

            static ['new'](name: string, value: string, domain: string, path: string, max_age: number): Cookie;

            // Static methods

            /**
             * Parses `header` and returns a #SoupCookie. (If `header` contains
             * multiple cookies, only the first one will be parsed.)
             *
             * If `header` does not have "path" or "domain" attributes, they will
             * be defaulted from `origin`. If `origin` is %NULL, path will default
             * to "/", but domain will be left as %NULL. Note that this is not a
             * valid state for a #SoupCookie, and you will need to fill in some
             * appropriate string for the domain if you want to actually make use
             * of the cookie.
             * @param header a cookie string (eg, the value of a Set-Cookie header)
             * @param origin origin of the cookie, or %NULL
             */
            static parse(header: string, origin: URI): Cookie | null;

            // Methods

            /**
             * Tests if `cookie` should be sent to `uri`.
             *
             * (At the moment, this does not check that `cookie'`s domain matches
             * `uri,` because it assumes that the caller has already done that.
             * But don't rely on that; it may change in the future.)
             * @param uri a #SoupURI
             * @returns %TRUE if @cookie should be sent to @uri, %FALSE if not
             */
            applies_to_uri(uri: URI): boolean;
            /**
             * Copies `cookie`.
             * @returns a copy of @cookie
             */
            copy(): Cookie;
            /**
             * Checks if the `cookie'`s domain and `host` match in the sense that
             * `cookie` should be sent when making a request to `host,` or that
             * `cookie` should be accepted when receiving a response from `host`.
             * @param host a URI
             * @returns %TRUE if the domains match, %FALSE otherwise
             */
            domain_matches(host: string): boolean;
            /**
             * Tests if `cookie1` and `cookie2` are equal.
             *
             * Note that currently, this does not check that the cookie domains
             * match. This may change in the future.
             * @param cookie2 a #SoupCookie
             * @returns whether the cookies are equal.
             */
            equal(cookie2: Cookie): boolean;
            /**
             * Frees `cookie`
             */
            free(): void;
            /**
             * Gets `cookie'`s domain
             * @returns @cookie's domain
             */
            get_domain(): string;
            /**
             * Gets `cookie'`s expiration time.
             * @returns @cookie's expiration time, which is owned by @cookie and should not be modified or freed.
             */
            get_expires(): Date | null;
            /**
             * Gets `cookie'`s HttpOnly attribute
             * @returns @cookie's HttpOnly attribute
             */
            get_http_only(): boolean;
            /**
             * Gets `cookie'`s name
             * @returns @cookie's name
             */
            get_name(): string;
            /**
             * Gets `cookie'`s path
             * @returns @cookie's path
             */
            get_path(): string;
            get_same_site_policy(): SameSitePolicy;
            /**
             * Gets `cookie'`s secure attribute
             * @returns @cookie's secure attribute
             */
            get_secure(): boolean;
            /**
             * Gets `cookie'`s value
             * @returns @cookie's value
             */
            get_value(): string;
            /**
             * Sets `cookie'`s domain to `domain`
             * @param domain the new domain
             */
            set_domain(domain: string): void;
            /**
             * Sets `cookie'`s expiration time to `expires`. If `expires` is %NULL,
             * `cookie` will be a session cookie and will expire at the end of the
             * client's session.
             *
             * (This sets the same property as soup_cookie_set_max_age().)
             * @param expires the new expiration time, or %NULL
             */
            set_expires(expires: Date): void;
            /**
             * Sets `cookie'`s HttpOnly attribute to `http_only`. If %TRUE, `cookie`
             * will be marked as "http only", meaning it should not be exposed to
             * web page scripts or other untrusted code.
             * @param http_only the new value for the HttpOnly attribute
             */
            set_http_only(http_only: boolean): void;
            /**
             * Sets `cookie'`s max age to `max_age`. If `max_age` is -1, the cookie
             * is a session cookie, and will expire at the end of the client's
             * session. Otherwise, it is the number of seconds until the cookie
             * expires. You can use the constants %SOUP_COOKIE_MAX_AGE_ONE_HOUR,
             * %SOUP_COOKIE_MAX_AGE_ONE_DAY, %SOUP_COOKIE_MAX_AGE_ONE_WEEK and
             * %SOUP_COOKIE_MAX_AGE_ONE_YEAR (or multiples thereof) to calculate
             * this value. (A value of 0 indicates that the cookie should be
             * considered already-expired.)
             *
             * (This sets the same property as soup_cookie_set_expires().)
             * @param max_age the new max age
             */
            set_max_age(max_age: number): void;
            /**
             * Sets `cookie'`s name to `name`
             * @param name the new name
             */
            set_name(name: string): void;
            /**
             * Sets `cookie'`s path to `path`
             * @param path the new path
             */
            set_path(path: string): void;
            /**
             * When used in conjunction with soup_cookie_jar_get_cookie_list_with_same_site_info() this
             * sets the policy of when this cookie should be exposed.
             * @param policy a #SoupSameSitePolicy
             */
            set_same_site_policy(policy: SameSitePolicy | null): void;
            /**
             * Sets `cookie'`s secure attribute to `secure`. If %TRUE, `cookie` will
             * only be transmitted from the client to the server over secure
             * (https) connections.
             * @param secure the new value for the secure attribute
             */
            set_secure(secure: boolean): void;
            /**
             * Sets `cookie'`s value to `value`
             * @param value the new value
             */
            set_value(value: string): void;
            /**
             * Serializes `cookie` in the format used by the Cookie header (ie, for
             * returning a cookie from a #SoupSession to a server).
             * @returns the header
             */
            to_cookie_header(): string;
            /**
             * Serializes `cookie` in the format used by the Set-Cookie header
             * (ie, for sending a cookie from a #SoupServer to a client).
             * @returns the header
             */
            to_set_cookie_header(): string;
        }

        type CookieJarClass = typeof CookieJar;
        type CookieJarDBClass = typeof CookieJarDB;
        type CookieJarTextClass = typeof CookieJarText;
        /**
         * A date and time. The date is assumed to be in the (proleptic)
         * Gregorian calendar. The time is in UTC if `utc` is %TRUE. Otherwise,
         * the time is a local time, and `offset` gives the offset from UTC in
         * minutes (such that adding `offset` to the time would give the
         * correct UTC time). If `utc` is %FALSE and `offset` is 0, then the
         * %SoupDate represents a "floating" time with no associated timezone
         * information.
         */
        class Date {
            static $gtype: GObject.GType<Date>;

            // Fields

            year: number;
            month: number;
            day: number;
            hour: number;
            minute: number;
            second: number;
            utc: boolean;
            offset: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    year: number;
                    month: number;
                    day: number;
                    hour: number;
                    minute: number;
                    second: number;
                    utc: boolean;
                    offset: number;
                }>,
            );
            _init(...args: any[]): void;

            static ['new'](
                year: number,
                month: number,
                day: number,
                hour: number,
                minute: number,
                second: number,
            ): Date;

            static new_from_now(offset_seconds: number): Date;

            static new_from_string(date_string: string): Date;

            static new_from_time_t(when: number): Date;

            // Methods

            /**
             * Copies `date`.
             */
            copy(): Date;
            /**
             * Frees `date`.
             */
            free(): void;
            /**
             * Gets `date'`s day.
             * @returns @date's day
             */
            get_day(): number;
            /**
             * Gets `date'`s hour.
             * @returns @date's hour
             */
            get_hour(): number;
            /**
             * Gets `date'`s minute.
             * @returns @date's minute
             */
            get_minute(): number;
            /**
             * Gets `date'`s month.
             * @returns @date's month
             */
            get_month(): number;
            /**
             * Gets `date'`s offset from UTC.
             * @returns @date's offset from UTC. If soup_date_get_utc() returns %FALSE but soup_date_get_offset() returns 0, that means the date is a "floating" time with no associated offset information.
             */
            get_offset(): number;
            /**
             * Gets `date'`s second.
             * @returns @date's second
             */
            get_second(): number;
            /**
             * Gets `date'`s UTC flag
             * @returns %TRUE if @date is UTC.
             */
            get_utc(): number;
            /**
             * Gets `date'`s year.
             * @returns @date's year
             */
            get_year(): number;
            /**
             * Determines if `date` is in the past.
             * @returns %TRUE if @date is in the past
             */
            is_past(): boolean;
            /**
             * Converts `date` to a string in the format described by `format`.
             * @param format the format to generate the date in
             * @returns @date as a string
             */
            to_string(format: DateFormat | null): string;
            /**
             * Converts `date` to a <type>time_t</type>, assumming it to be in
             * UTC.
             *
             * If `date` is not representable as a <type>time_t</type>, it will be
             * clamped into range. (In particular, some HTTP cookies have
             * expiration dates after "Y2.038k" (2038-01-19T03:14:07Z).)
             * @returns @date as a <type>time_t</type>
             */
            to_time_t(): number;
            /**
             * Converts `date` to a #GTimeVal.
             */
            to_timeval(): GLib.TimeVal;
        }

        type HSTSEnforcerClass = typeof HSTSEnforcer;
        type HSTSEnforcerDBClass = typeof HSTSEnforcerDB;
        abstract class HSTSEnforcerDBPrivate {
            static $gtype: GObject.GType<HSTSEnforcerDBPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        abstract class HSTSEnforcerPrivate {
            static $gtype: GObject.GType<HSTSEnforcerPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        /**
         * An HTTP Strict Transport Security policy.
         *
         * `domain` represents the host that this policy applies to. The domain
         * must be IDNA-canonicalized. soup_hsts_policy_new() and related methods
         * will do this for you.
         *
         * `max_age` contains the 'max-age' value from the Strict Transport
         * Security header and indicates the time to live of this policy,
         * in seconds.
         *
         * `expires` will be non-%NULL if the policy has been set by the host and
         * hence has an expiry time. If `expires` is %NULL, it indicates that the
         * policy is a permanent session policy set by the user agent.
         *
         * If `include_subdomains` is %TRUE, the Strict Transport Security policy
         * must also be enforced on subdomains of `domain`.
         */
        class HSTSPolicy {
            static $gtype: GObject.GType<HSTSPolicy>;

            // Fields

            domain: string;
            max_age: number;
            expires: Date;
            include_subdomains: boolean;

            // Constructors

            constructor(
                properties?: Partial<{
                    domain: string;
                    max_age: number;
                    include_subdomains: boolean;
                }>,
            );
            _init(...args: any[]): void;

            static ['new'](domain: string, max_age: number, include_subdomains: boolean): HSTSPolicy;

            static new_from_response(msg: Message): HSTSPolicy;

            static new_full(domain: string, max_age: number, expires: Date, include_subdomains: boolean): HSTSPolicy;

            static new_session_policy(domain: string, include_subdomains: boolean): HSTSPolicy;

            // Methods

            /**
             * Copies `policy`.
             * @returns a copy of @policy
             */
            copy(): HSTSPolicy;
            /**
             * Tests if `policy1` and `policy2` are equal.
             * @param policy2 a #SoupHSTSPolicy
             * @returns whether the policies are equal.
             */
            equal(policy2: HSTSPolicy): boolean;
            /**
             * Frees `policy`.
             */
            free(): void;
            /**
             * Gets `policy'`s domain.
             * @returns @policy's domain.
             */
            get_domain(): string;
            /**
             * Gets whether `policy` include its subdomains.
             * @returns %TRUE if @policy includes subdomains, %FALSE otherwise.
             */
            includes_subdomains(): boolean;
            /**
             * Gets whether `policy` is expired. Permanent policies never
             * expire.
             * @returns %TRUE if @policy is expired, %FALSE otherwise.
             */
            is_expired(): boolean;
            /**
             * Gets whether `policy` is a non-permanent, non-expirable session policy.
             * see soup_hsts_policy_new_session_policy() for details.
             * @returns %TRUE if @policy is permanent, %FALSE otherwise
             */
            is_session_policy(): boolean;
        }

        type LoggerClass = typeof Logger;
        /**
         * A #SoupMessage request or response body.
         *
         * Note that while `length` always reflects the full length of the
         * message body, `data` is normally %NULL, and will only be filled in
         * after soup_message_body_flatten() is called. For client-side
         * messages, this automatically happens for the response body after it
         * has been fully read, unless you set the
         * %SOUP_MESSAGE_OVERWRITE_CHUNKS flags. Likewise, for server-side
         * messages, the request body is automatically filled in after being
         * read.
         *
         * As an added bonus, when `data` is filled in, it is always terminated
         * with a '\0' byte (which is not reflected in `length)`.
         */
        class MessageBody {
            static $gtype: GObject.GType<MessageBody>;

            // Fields

            data: string;
            length: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    data: string;
                    length: number;
                }>,
            );
            _init(...args: any[]): void;

            static ['new'](): MessageBody;

            // Methods

            /**
             * Appends `length` bytes from `data` to `body` according to `use`.
             * @param use how to use @data
             * @param data data to append
             */
            append(use: MemoryUse | null, data: Uint8Array | string): void;
            /**
             * Appends the data from `buffer` to `body`. (#SoupMessageBody uses
             * #SoupBuffers internally, so this is normally a constant-time
             * operation that doesn't actually require copying the data in
             * `buffer`.)
             * @param buffer a #SoupBuffer
             */
            append_buffer(buffer: Buffer): void;
            /**
             * Appends `length` bytes from `data` to `body`.
             *
             * This function is exactly equivalent to soup_message_body_append()
             * with %SOUP_MEMORY_TAKE as second argument; it exists mainly for
             * convenience and simplifying language bindings.
             * @param data data to append
             */
            append(data: Uint8Array | string): void;
            /**
             * Tags `body` as being complete; Call this when using chunked encoding
             * after you have appended the last chunk.
             */
            complete(): void;
            /**
             * Fills in `body'`s data field with a buffer containing all of the
             * data in `body` (plus an additional '\0' byte not counted by `body'`s
             * length field).
             * @returns a #SoupBuffer containing the same data as @body. (You must free this buffer if you do not want it.)
             */
            flatten(): Buffer;
            /**
             * Frees `body`. You will not normally need to use this, as
             * #SoupMessage frees its associated message bodies automatically.
             */
            free(): void;
            /**
             * Gets the accumulate flag on `body;` see
             * soup_message_body_set_accumulate() for details.
             * @returns the accumulate flag for @body.
             */
            get_accumulate(): boolean;
            /**
             * Gets a #SoupBuffer containing data from `body` starting at `offset`.
             * The size of the returned chunk is unspecified. You can iterate
             * through the entire body by first calling
             * soup_message_body_get_chunk() with an offset of 0, and then on each
             * successive call, increment the offset by the length of the
             * previously-returned chunk.
             *
             * If `offset` is greater than or equal to the total length of `body,`
             * then the return value depends on whether or not
             * soup_message_body_complete() has been called or not; if it has,
             * then soup_message_body_get_chunk() will return a 0-length chunk
             * (indicating the end of `body)`. If it has not, then
             * soup_message_body_get_chunk() will return %NULL (indicating that
             * `body` may still potentially have more data, but that data is not
             * currently available).
             * @param offset an offset
             * @returns a #SoupBuffer, or %NULL.
             */
            get_chunk(offset: number): Buffer | null;
            /**
             * Handles the #SoupMessageBody part of receiving a chunk of data from
             * the network. Normally this means appending `chunk` to `body,` exactly
             * as with soup_message_body_append_buffer(), but if you have set
             * `body'`s accumulate flag to %FALSE, then that will not happen.
             *
             * This is a low-level method which you should not normally need to
             * use.
             * @param chunk a #SoupBuffer received from the network
             */
            got_chunk(chunk: Buffer): void;
            /**
             * Sets or clears the accumulate flag on `body`. (The default value is
             * %TRUE.) If set to %FALSE, `body'`s %data field will not be filled in
             * after the body is fully sent/received, and the chunks that make up
             * `body` may be discarded when they are no longer needed.
             *
             * In particular, if you set this flag to %FALSE on an "incoming"
             * message body (that is, the #SoupMessage:response_body of a
             * client-side message, or #SoupMessage:request_body of a server-side
             * message), this will cause each chunk of the body to be discarded
             * after its corresponding #SoupMessage::got_chunk signal is emitted.
             * (This is equivalent to setting the deprecated
             * %SOUP_MESSAGE_OVERWRITE_CHUNKS flag on the message.)
             *
             * If you set this flag to %FALSE on the #SoupMessage:response_body of
             * a server-side message, it will cause each chunk of the body to be
             * discarded after its corresponding #SoupMessage::wrote_chunk signal
             * is emitted.
             *
             * If you set the flag to %FALSE on the #SoupMessage:request_body of a
             * client-side message, it will block the accumulation of chunks into
             * `body'`s %data field, but it will not normally cause the chunks to
             * be discarded after being written like in the server-side
             * #SoupMessage:response_body case, because the request body needs to
             * be kept around in case the request needs to be sent a second time
             * due to redirection or authentication. However, if you set the
             * %SOUP_MESSAGE_CAN_REBUILD flag on the message, then the chunks will
             * be discarded, and you will be responsible for recreating the
             * request body after the #SoupMessage::restarted signal is emitted.
             * @param accumulate whether or not to accumulate body chunks in @body
             */
            set_accumulate(accumulate: boolean): void;
            /**
             * Deletes all of the data in `body`.
             */
            truncate(): void;
            /**
             * Handles the #SoupMessageBody part of writing a chunk of data to the
             * network. Normally this is a no-op, but if you have set `body'`s
             * accumulate flag to %FALSE, then this will cause `chunk` to be
             * discarded to free up memory.
             *
             * This is a low-level method which you should not need to use, and
             * there are further restrictions on its proper use which are not
             * documented here.
             * @param chunk a #SoupBuffer returned from soup_message_body_get_chunk()
             */
            wrote_chunk(chunk: Buffer): void;
        }

        type MessageClass = typeof Message;
        /**
         * The HTTP message headers associated with a request or response.
         */
        class MessageHeaders {
            static $gtype: GObject.GType<MessageHeaders>;

            // Constructors

            constructor(type: MessageHeadersType);
            _init(...args: any[]): void;

            static ['new'](type: MessageHeadersType): MessageHeaders;

            // Methods

            /**
             * Appends a new header with name `name` and value `value` to `hdrs`. (If
             * there is an existing header with name `name,` then this creates a
             * second one, which is only allowed for list-valued headers; see also
             * soup_message_headers_replace().)
             *
             * The caller is expected to make sure that `name` and `value` are
             * syntactically correct.
             * @param name the header name to add
             * @param value the new value of @name
             */
            append(name: string, value: string): void;
            /**
             * Removes all the headers listed in the Connection header.
             */
            clean_connection_headers(): void;
            /**
             * Clears `hdrs`.
             */
            clear(): void;
            /**
             * Calls `func` once for each header value in `hdrs`.
             *
             * Beware that unlike soup_message_headers_get(), this processes the
             * headers in exactly the way they were added, rather than
             * concatenating multiple same-named headers into a single value.
             * (This is intentional; it ensures that if you call
             * soup_message_headers_append() multiple times with the same name,
             * then the I/O code will output multiple copies of the header when
             * sending the message to the remote implementation, which may be
             * required for interoperability in some cases.)
             *
             * You may not modify the headers from `func`.
             * @param func callback function to run for each header
             */
            foreach(func: MessageHeadersForeachFunc): void;
            /**
             * Frees `hdrs`.
             */
            free(): void;
            /**
             * Frees the array of ranges returned from soup_message_headers_get_ranges().
             * @param ranges an array of #SoupRange
             */
            free_ranges(ranges: Range): void;
            /**
             * Gets the value of header `name` in `hdrs`.
             *
             * This method was supposed to work correctly for both single-valued
             * and list-valued headers, but because some HTTP clients/servers
             * mistakenly send multiple copies of headers that are supposed to be
             * single-valued, it sometimes returns incorrect results. To fix this,
             * the methods soup_message_headers_get_one() and
             * soup_message_headers_get_list() were introduced, so callers can
             * explicitly state which behavior they are expecting.
             * @param name header name
             * @returns as with soup_message_headers_get_list().
             */
            get(name: string): string | null;
            /**
             * Looks up the "Content-Disposition" header in `hdrs,` parses it, and
             * returns its value in *`disposition` and *`params`. `params` can be
             * %NULL if you are only interested in the disposition-type.
             *
             * In HTTP, the most common use of this header is to set a
             * disposition-type of "attachment", to suggest to the browser that a
             * response should be saved to disk rather than displayed in the
             * browser. If `params` contains a "filename" parameter, this is a
             * suggestion of a filename to use. (If the parameter value in the
             * header contains an absolute or relative path, libsoup will truncate
             * it down to just the final path component, so you do not need to
             * test this yourself.)
             *
             * Content-Disposition is also used in "multipart/form-data", however
             * this is handled automatically by #SoupMultipart and the associated
             * form methods.
             * @returns %TRUE if @hdrs contains a "Content-Disposition" header, %FALSE if not (in which case *@disposition and *@params will be unchanged).
             */
            get_content_disposition(): [boolean, string, GLib.HashTable<string, string>];
            /**
             * Gets the message body length that `hdrs` declare. This will only
             * be non-0 if soup_message_headers_get_encoding() returns
             * %SOUP_ENCODING_CONTENT_LENGTH.
             * @returns the message body length declared by @hdrs.
             */
            get_content_length(): number;
            /**
             * Parses `hdrs'`s Content-Range header and returns it in `start,`
             * `end,` and `total_length`. If the total length field in the header
             * was specified as "*", then `total_length` will be set to -1.
             * @returns %TRUE if @hdrs contained a "Content-Range" header containing a byte range which could be parsed, %FALSE otherwise.
             */
            get_content_range(): [boolean, number, number, number];
            /**
             * Looks up the "Content-Type" header in `hdrs,` parses it, and returns
             * its value in *`content_type` and *`params`. `params` can be %NULL if you
             * are only interested in the content type itself.
             * @returns a string with the value of the "Content-Type" header or %NULL if @hdrs does not contain that header or it cannot be parsed (in which case *@params will be unchanged).
             */
            get_content_type(): [string | null, GLib.HashTable<string, string> | null];
            /**
             * Gets the message body encoding that `hdrs` declare. This may not
             * always correspond to the encoding used on the wire; eg, a HEAD
             * response may declare a Content-Length or Transfer-Encoding, but
             * it will never actually include a body.
             * @returns the encoding declared by @hdrs.
             */
            get_encoding(): Encoding;
            /**
             * Gets the expectations declared by `hdrs'`s "Expect" header.
             * Currently this will either be %SOUP_EXPECTATION_CONTINUE or
             * %SOUP_EXPECTATION_UNRECOGNIZED.
             * @returns the contents of @hdrs's "Expect" header
             */
            get_expectations(): Expectation;
            /**
             * Gets the type of headers.
             * @returns the header's type.
             */
            get_headers_type(): MessageHeadersType;
            /**
             * Gets the value of header `name` in `hdrs`. Use this for headers whose
             * values are comma-delimited lists, and which are therefore allowed
             * to appear multiple times in the headers. For non-list-valued
             * headers, use soup_message_headers_get_one().
             *
             * If `name` appears multiple times in `hdrs,`
             * soup_message_headers_get_list() will concatenate all of the values
             * together, separated by commas. This is sometimes awkward to parse
             * (eg, WWW-Authenticate, Set-Cookie), but you have to be able to deal
             * with it anyway, because the HTTP spec explicitly states that this
             * transformation is allowed, and so an upstream proxy could do the
             * same thing.
             * @param name header name
             * @returns the header's value or %NULL if not found.
             */
            get_list(name: string): string | null;
            /**
             * Gets the value of header `name` in `hdrs`. Use this for headers whose
             * values are <emphasis>not</emphasis> comma-delimited lists, and
             * which therefore can only appear at most once in the headers. For
             * list-valued headers, use soup_message_headers_get_list().
             *
             * If `hdrs` does erroneously contain multiple copies of the header, it
             * is not defined which one will be returned. (Ideally, it will return
             * whichever one makes libsoup most compatible with other HTTP
             * implementations.)
             * @param name header name
             * @returns the header's value or %NULL if not found.
             */
            get_one(name: string): string | null;
            /**
             * Parses `hdrs'`s Range header and returns an array of the requested
             * byte ranges. The returned array must be freed with
             * soup_message_headers_free_ranges().
             *
             * If `total_length` is non-0, its value will be used to adjust the
             * returned ranges to have explicit start and end values, and the
             * returned ranges will be sorted and non-overlapping. If
             * `total_length` is 0, then some ranges may have an end value of -1,
             * as described under #SoupRange, and some of the ranges may be
             * redundant.
             *
             * Beware that even if given a `total_length,` this function does not
             * check that the ranges are satisfiable.
             *
             * <note><para>
             * #SoupServer has built-in handling for range requests. If your
             * server handler returns a %SOUP_STATUS_OK response containing the
             * complete response body (rather than pausing the message and
             * returning some of the response body later), and there is a Range
             * header in the request, then libsoup will automatically convert the
             * response to a %SOUP_STATUS_PARTIAL_CONTENT response containing only
             * the range(s) requested by the client.
             *
             * The only time you need to process the Range header yourself is if
             * either you need to stream the response body rather than returning
             * it all at once, or you do not already have the complete response
             * body available, and only want to generate the parts that were
             * actually requested by the client.
             * </para></note>
             * @param total_length the total_length of the response body
             * @returns %TRUE if @hdrs contained a syntactically-valid "Range" header, %FALSE otherwise (in which case @range and @length will not be set).
             */
            get_ranges(total_length: number): [boolean, Range[]];
            /**
             * Checks whether the list-valued header `name` is present in `hdrs,`
             * and contains a case-insensitive match for `token`.
             *
             * (If `name` is present in `hdrs,` then this is equivalent to calling
             * soup_header_contains() on its value.)
             * @param name header name
             * @param token token to look for
             * @returns %TRUE if the header is present and contains @token,   %FALSE otherwise.
             */
            header_contains(name: string, token: string): boolean;
            /**
             * Checks whether the header `name` is present in `hdrs` and is
             * (case-insensitively) equal to `value`.
             * @param name header name
             * @param value expected value
             * @returns %TRUE if the header is present and its value is   @value, %FALSE otherwise.
             */
            header_equals(name: string, value: string): boolean;
            /**
             * Removes `name` from `hdrs`. If there are multiple values for `name,`
             * they are all removed.
             * @param name the header name to remove
             */
            remove(name: string): void;
            /**
             * Replaces the value of the header `name` in `hdrs` with `value`. (See
             * also soup_message_headers_append().)
             *
             * The caller is expected to make sure that `name` and `value` are
             * syntactically correct.
             * @param name the header name to replace
             * @param value the new value of @name
             */
            replace(name: string, value: string): void;
            /**
             * Sets the "Content-Disposition" header in `hdrs` to `disposition,`
             * optionally with additional parameters specified in `params`.
             *
             * See soup_message_headers_get_content_disposition() for a discussion
             * of how Content-Disposition is used in HTTP.
             * @param disposition the disposition-type
             * @param params additional parameters, or %NULL
             */
            set_content_disposition(disposition: string, params?: GLib.HashTable<string, string> | null): void;
            /**
             * Sets the message body length that `hdrs` will declare, and sets
             * `hdrs'`s encoding to %SOUP_ENCODING_CONTENT_LENGTH.
             *
             * You do not normally need to call this; if `hdrs` is set to use
             * Content-Length encoding, libsoup will automatically set its
             * Content-Length header for you immediately before sending the
             * headers. One situation in which this method is useful is when
             * generating the response to a HEAD request; Calling
             * soup_message_headers_set_content_length() allows you to put the
             * correct content length into the response without needing to waste
             * memory by filling in a response body which won't actually be sent.
             * @param content_length the message body length
             */
            set_content_length(content_length: number): void;
            /**
             * Sets `hdrs'`s Content-Range header according to the given values.
             * (Note that `total_length` is the total length of the entire resource
             * that this is a range of, not simply `end` - `start` + 1.)
             *
             * <note><para>
             * #SoupServer has built-in handling for range requests, and you do
             * not normally need to call this function youself. See
             * soup_message_headers_get_ranges() for more details.
             * </para></note>
             * @param start the start of the range
             * @param end the end of the range
             * @param total_length the total length of the resource, or -1 if unknown
             */
            set_content_range(start: number, end: number, total_length: number): void;
            /**
             * Sets the "Content-Type" header in `hdrs` to `content_type,`
             * optionally with additional parameters specified in `params`.
             * @param content_type the MIME type
             * @param params additional parameters, or %NULL
             */
            set_content_type(content_type: string, params?: GLib.HashTable<string, string> | null): void;
            /**
             * Sets the message body encoding that `hdrs` will declare. In particular,
             * you should use this if you are going to send a request or response in
             * chunked encoding.
             * @param encoding a #SoupEncoding
             */
            set_encoding(encoding: Encoding | null): void;
            /**
             * Sets `hdrs'`s "Expect" header according to `expectations`.
             *
             * Currently %SOUP_EXPECTATION_CONTINUE is the only known expectation
             * value. You should set this value on a request if you are sending a
             * large message body (eg, via POST or PUT), and want to give the
             * server a chance to reject the request after seeing just the headers
             * (eg, because it will require authentication before allowing you to
             * post, or because you're POSTing to a URL that doesn't exist). This
             * saves you from having to transmit the large request body when the
             * server is just going to ignore it anyway.
             * @param expectations the expectations to set
             */
            set_expectations(expectations: Expectation | null): void;
            /**
             * Sets `hdrs'`s Range header to request the indicated range.
             * `start` and `end` are interpreted as in a #SoupRange.
             *
             * If you need to request multiple ranges, use
             * soup_message_headers_set_ranges().
             * @param start the start of the range to request
             * @param end the end of the range to request
             */
            set_range(start: number, end: number): void;
            /**
             * Sets `hdrs'`s Range header to request the indicated ranges. (If you
             * only want to request a single range, you can use
             * soup_message_headers_set_range().)
             * @param ranges an array of #SoupRange
             * @param length the length of @range
             */
            set_ranges(ranges: Range, length: number): void;
        }

        /**
         * An opaque type used to iterate over a %SoupMessageHeaders
         * structure.
         *
         * After intializing the iterator with
         * soup_message_headers_iter_init(), call
         * soup_message_headers_iter_next() to fetch data from it.
         *
         * You may not modify the headers while iterating over them.
         */
        class MessageHeadersIter {
            static $gtype: GObject.GType<MessageHeadersIter>;

            // Constructors

            constructor(properties?: Partial<{}>);
            _init(...args: any[]): void;

            // Static methods

            /**
             * Initializes `iter` for iterating `hdrs`.
             * @param hdrs a %SoupMessageHeaders
             */
            static init(hdrs: MessageHeaders): MessageHeadersIter;
            /**
             * Yields the next name/value pair in the %SoupMessageHeaders being
             * iterated by `iter`. If `iter` has already yielded the last header,
             * then soup_message_headers_iter_next() will return %FALSE and `name`
             * and `value` will be unchanged.
             * @param iter a %SoupMessageHeadersIter
             */
            static next(iter: MessageHeadersIter): [boolean, MessageHeadersIter, string, string];
        }

        abstract class MessageQueue {
            static $gtype: GObject.GType<MessageQueue>;

            // Constructors

            _init(...args: any[]): void;
        }

        abstract class MessageQueueItem {
            static $gtype: GObject.GType<MessageQueueItem>;

            // Constructors

            _init(...args: any[]): void;
        }

        /**
         * Represents a multipart HTTP message body, parsed according to the
         * syntax of RFC 2046. Of particular interest to HTTP are
         * <literal>multipart/byte-ranges</literal> and
         * <literal>multipart/form-data</literal>.
         *
         * Although the headers of a #SoupMultipart body part will contain the
         * full headers from that body part, libsoup does not interpret them
         * according to MIME rules. For example, each body part is assumed to
         * have "binary" Content-Transfer-Encoding, even if its headers
         * explicitly state otherwise. In other words, don't try to use
         * #SoupMultipart for handling real MIME multiparts.
         */
        class Multipart {
            static $gtype: GObject.GType<Multipart>;

            // Constructors

            constructor(mime_type: string);
            _init(...args: any[]): void;

            static ['new'](mime_type: string): Multipart;

            static new_from_message(headers: MessageHeaders, body: MessageBody): Multipart;

            // Methods

            /**
             * Adds a new MIME part containing `body` to `multipart,` using
             * "Content-Disposition: form-data", as per the HTML forms
             * specification. See soup_form_request_new_from_multipart() for more
             * details.
             * @param control_name the name of the control associated with this file
             * @param filename the name of the file, or %NULL if not known
             * @param content_type the MIME type of the file, or %NULL if not known
             * @param body the file data
             */
            append_form_file(control_name: string, filename: string, content_type: string, body: Buffer): void;
            /**
             * Adds a new MIME part containing `data` to `multipart,` using
             * "Content-Disposition: form-data", as per the HTML forms
             * specification. See soup_form_request_new_from_multipart() for more
             * details.
             * @param control_name the name of the control associated with @data
             * @param data the body data
             */
            append_form_string(control_name: string, data: string): void;
            /**
             * Adds a new MIME part to `multipart` with the given headers and body.
             * (The multipart will make its own copies of `headers` and `body,` so
             * you should free your copies if you are not using them for anything
             * else.)
             * @param headers the MIME part headers
             * @param body the MIME part body
             */
            append_part(headers: MessageHeaders, body: Buffer): void;
            /**
             * Frees `multipart`
             */
            free(): void;
            /**
             * Gets the number of body parts in `multipart`
             * @returns the number of body parts in @multipart
             */
            get_length(): number;
            /**
             * Gets the indicated body part from `multipart`.
             * @param part the part number to get (counting from 0)
             * @returns %TRUE on success, %FALSE if @part is out of range (in which case @headers and @body won't be set)
             */
            get_part(part: number): [boolean, MessageHeaders, Buffer];
            /**
             * Serializes `multipart` to `dest_headers` and `dest_body`.
             * @param dest_headers the headers of the HTTP message to serialize @multipart to
             * @param dest_body the body of the HTTP message to serialize @multipart to
             */
            to_message(dest_headers: MessageHeaders, dest_body: MessageBody): void;
        }

        type MultipartInputStreamClass = typeof MultipartInputStream;
        abstract class MultipartInputStreamPrivate {
            static $gtype: GObject.GType<MultipartInputStreamPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type PasswordManagerInterface = typeof PasswordManager;
        type ProxyResolverDefaultClass = typeof ProxyResolverDefault;
        type ProxyResolverInterface = typeof ProxyResolver;
        type ProxyURIResolverInterface = typeof ProxyURIResolver;
        /**
         * Represents a byte range as used in the Range header.
         *
         * If `end` is non-negative, then `start` and `end` represent the bounds
         * of of the range, counting from 0. (Eg, the first 500 bytes would be
         * represented as `start` = 0 and `end` = 499.)
         *
         * If `end` is -1 and `start` is non-negative, then this represents a
         * range starting at `start` and ending with the last byte of the
         * requested resource body. (Eg, all but the first 500 bytes would be
         * `start` = 500, and `end` = -1.)
         *
         * If `end` is -1 and `start` is negative, then it represents a "suffix
         * range", referring to the last -`start` bytes of the resource body.
         * (Eg, the last 500 bytes would be `start` = -500 and `end` = -1.)
         */
        class Range {
            static $gtype: GObject.GType<Range>;

            // Fields

            start: number;
            end: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    start: number;
                    end: number;
                }>,
            );
            _init(...args: any[]): void;
        }

        type RequestClass = typeof Request;
        type RequestDataClass = typeof RequestData;
        abstract class RequestDataPrivate {
            static $gtype: GObject.GType<RequestDataPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type RequestFileClass = typeof RequestFile;
        abstract class RequestFilePrivate {
            static $gtype: GObject.GType<RequestFilePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type RequestHTTPClass = typeof RequestHTTP;
        abstract class RequestHTTPPrivate {
            static $gtype: GObject.GType<RequestHTTPPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        abstract class RequestPrivate {
            static $gtype: GObject.GType<RequestPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type RequesterClass = typeof Requester;
        abstract class RequesterPrivate {
            static $gtype: GObject.GType<RequesterPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type ServerClass = typeof Server;
        type SessionAsyncClass = typeof SessionAsync;
        type SessionClass = typeof Session;
        type SessionFeatureInterface = typeof SessionFeature;
        type SessionSyncClass = typeof SessionSync;
        type SocketClass = typeof Socket;
        /**
         * A #SoupURI represents a (parsed) URI. #SoupURI supports RFC 3986
         * (URI Generic Syntax), and can parse any valid URI. However, libsoup
         * only uses "http" and "https" URIs internally; You can use
         * SOUP_URI_VALID_FOR_HTTP() to test if a #SoupURI is a valid HTTP
         * URI.
         *
         * `scheme` will always be set in any URI. It is an interned string and
         * is always all lowercase. (If you parse a URI with a non-lowercase
         * scheme, it will be converted to lowercase.) The macros
         * %SOUP_URI_SCHEME_HTTP and %SOUP_URI_SCHEME_HTTPS provide the
         * interned values for "http" and "https" and can be compared against
         * URI `scheme` values.
         *
         * `user` and `password` are parsed as defined in the older URI specs
         * (ie, separated by a colon; RFC 3986 only talks about a single
         * "userinfo" field). Note that `password` is not included in the
         * output of soup_uri_to_string(). libsoup does not normally use these
         * fields; authentication is handled via #SoupSession signals.
         *
         * `host` contains the hostname, and `port` the port specified in the
         * URI. If the URI doesn't contain a hostname, `host` will be %NULL,
         * and if it doesn't specify a port, `port` may be 0. However, for
         * "http" and "https" URIs, `host` is guaranteed to be non-%NULL
         * (trying to parse an http URI with no `host` will return %NULL), and
         * `port` will always be non-0 (because libsoup knows the default value
         * to use when it is not specified in the URI).
         *
         * `path` is always non-%NULL. For http/https URIs, `path` will never be
         * an empty string either; if the input URI has no path, the parsed
         * #SoupURI will have a `path` of "/".
         *
         * `query` and `fragment` are optional for all URI types.
         * soup_form_decode() may be useful for parsing `query`.
         *
         * Note that `path,` `query,` and `fragment` may contain
         * %<!-- -->-encoded characters. soup_uri_new() calls
         * soup_uri_normalize() on them, but not soup_uri_decode(). This is
         * necessary to ensure that soup_uri_to_string() will generate a URI
         * that has exactly the same meaning as the original. (In theory,
         * #SoupURI should leave `user,` `password,` and `host` partially-encoded
         * as well, but this would be more annoying than useful.)
         */
        class URI {
            static $gtype: GObject.GType<URI>;

            // Fields

            scheme: string;
            user: string;
            password: string;
            host: string;
            port: number;
            path: string;
            query: string;
            fragment: string;

            // Constructors

            constructor(
                properties?: Partial<{
                    scheme: string;
                    user: string;
                    password: string;
                    host: string;
                    port: number;
                    path: string;
                    query: string;
                    fragment: string;
                }>,
            );
            _init(...args: any[]): void;

            static ['new'](uri_string?: string | null): URI;

            static new_with_base(base: URI, uri_string: string): URI;

            // Static methods

            /**
             * Fully %<!-- -->-decodes `part`.
             *
             * In the past, this would return %NULL if `part` contained invalid
             * percent-encoding, but now it just ignores the problem (as
             * soup_uri_new() already did).
             * @param part a URI part
             */
            static decode(part: string): string;
            /**
             * This %<!-- -->-encodes the given URI part and returns the escaped
             * version in allocated memory, which the caller must free when it is
             * done.
             * @param part a URI part
             * @param escape_extra additional reserved characters to escape (or %NULL)
             */
            static encode(part: string, escape_extra?: string | null): string;
            /**
             * %<!-- -->-decodes any "unreserved" characters (or characters in
             * `unescape_extra)` in `part,` and %<!-- -->-encodes any non-ASCII
             * characters, spaces, and non-printing characters in `part`.
             *
             * "Unreserved" characters are those that are not allowed to be used
             * for punctuation according to the URI spec. For example, letters are
             * unreserved, so soup_uri_normalize() will turn
             * <literal>http://example.com/foo/b%<!-- -->61r</literal> into
             * <literal>http://example.com/foo/bar</literal>, which is guaranteed
             * to mean the same thing. However, "/" is "reserved", so
             * <literal>http://example.com/foo%<!-- -->2Fbar</literal> would not
             * be changed, because it might mean something different to the
             * server.
             *
             * In the past, this would return %NULL if `part` contained invalid
             * percent-encoding, but now it just ignores the problem (as
             * soup_uri_new() already did).
             * @param part a URI part
             * @param unescape_extra reserved characters to unescape (or %NULL)
             */
            static normalize(part: string, unescape_extra?: string | null): string;

            // Methods

            /**
             * Copies `uri`
             * @returns a copy of @uri, which must be freed with soup_uri_free()
             */
            copy(): URI;
            /**
             * Makes a copy of `uri,` considering only the protocol, host, and port
             * @returns the new #SoupURI
             */
            copy_host(): URI;
            /**
             * Tests whether or not `uri1` and `uri2` are equal in all parts
             * @param uri2 another #SoupURI
             * @returns %TRUE or %FALSE
             */
            equal(uri2: URI): boolean;
            /**
             * Frees `uri`.
             */
            free(): void;
            /**
             * Gets `uri'`s fragment.
             * @returns @uri's fragment.
             */
            get_fragment(): string;
            /**
             * Gets `uri'`s host.
             * @returns @uri's host.
             */
            get_host(): string;
            /**
             * Gets `uri'`s password.
             * @returns @uri's password.
             */
            get_password(): string;
            /**
             * Gets `uri'`s path.
             * @returns @uri's path.
             */
            get_path(): string;
            /**
             * Gets `uri'`s port.
             * @returns @uri's port.
             */
            get_port(): number;
            /**
             * Gets `uri'`s query.
             * @returns @uri's query.
             */
            get_query(): string;
            /**
             * Gets `uri'`s scheme.
             * @returns @uri's scheme.
             */
            get_scheme(): string;
            /**
             * Gets `uri'`s user.
             * @returns @uri's user.
             */
            get_user(): string;
            /**
             * Compares `v1` and `v2`, considering only the scheme, host, and port.
             * @param v2 a #SoupURI with a non-%NULL @host member
             * @returns whether or not the URIs are equal in scheme, host, and port.
             */
            host_equal(v2: URI): boolean;
            /**
             * Hashes `key,` considering only the scheme, host, and port.
             * @returns a hash
             */
            host_hash(): number;
            /**
             * Sets `uri'`s fragment to `fragment`.
             * @param fragment the fragment
             */
            set_fragment(fragment?: string | null): void;
            /**
             * Sets `uri'`s host to `host`.
             *
             * If `host` is an IPv6 IP address, it should not include the brackets
             * required by the URI syntax; they will be added automatically when
             * converting `uri` to a string.
             *
             * http and https URIs should not have a %NULL `host`.
             * @param host the hostname or IP address, or %NULL
             */
            set_host(host?: string | null): void;
            /**
             * Sets `uri'`s password to `password`.
             * @param password the password, or %NULL
             */
            set_password(password?: string | null): void;
            /**
             * Sets `uri'`s path to `path`.
             * @param path the non-%NULL path
             */
            set_path(path: string): void;
            /**
             * Sets `uri'`s port to `port`. If `port` is 0, `uri` will not have an
             * explicitly-specified port.
             * @param port the port, or 0
             */
            set_port(port: number): void;
            /**
             * Sets `uri'`s query to `query`.
             * @param query the query
             */
            set_query(query?: string | null): void;
            /**
             * Sets `uri'`s query to the result of encoding `form` according to the
             * HTML form rules. See soup_form_encode_hash() for more information.
             * @param form a #GHashTable containing HTML form information
             */
            set_query_from_form(form: { [key: string]: any } | GLib.HashTable<string, string>): void;
            /**
             * Sets `uri'`s scheme to `scheme`. This will also set `uri'`s port to
             * the default port for `scheme,` if known.
             * @param scheme the URI scheme
             */
            set_scheme(scheme: string): void;
            /**
             * Sets `uri'`s user to `user`.
             * @param user the username, or %NULL
             */
            set_user(user?: string | null): void;
            /**
             * Returns a string representing `uri`.
             *
             * If `just_path_and_query` is %TRUE, this concatenates the path and query
             * together. That is, it constructs the string that would be needed in
             * the Request-Line of an HTTP request for `uri`.
             *
             * Note that the output will never contain a password, even if `uri`
             * does.
             * @param just_path_and_query if %TRUE, output just the path and query portions
             * @returns a string representing @uri, which the caller must free.
             */
            to_string(just_path_and_query: boolean): string;
            /**
             * Tests if `uri` uses the default port for its scheme. (Eg, 80 for
             * http.) (This only works for http, https and ftp; libsoup does not know
             * the default ports of other protocols.)
             * @returns %TRUE or %FALSE
             */
            uses_default_port(): boolean;
        }

        type WebsocketConnectionClass = typeof WebsocketConnection;
        abstract class WebsocketConnectionPrivate {
            static $gtype: GObject.GType<WebsocketConnectionPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type WebsocketExtensionClass = typeof WebsocketExtension;
        type WebsocketExtensionDeflateClass = typeof WebsocketExtensionDeflate;
        type WebsocketExtensionManagerClass = typeof WebsocketExtensionManager;
        /**
         * Opaque structure containing XML-RPC methodCall parameter values.
         * Can be parsed using soup_xmlrpc_params_parse() and freed with
         * soup_xmlrpc_params_free().
         */
        abstract class XMLRPCParams {
            static $gtype: GObject.GType<XMLRPCParams>;

            // Constructors

            _init(...args: any[]): void;

            // Methods

            /**
             * Free a #SoupXMLRPCParams returned by soup_xmlrpc_parse_request().
             */
            free(): void;
            /**
             * Parse method parameters returned by soup_xmlrpc_parse_request().
             *
             * Deserialization details:
             *  - If `signature` is provided, &lt;int&gt; and &lt;i4&gt; can be deserialized
             *    to byte, int16, uint16, int32, uint32, int64 or uint64. Otherwise
             *    it will be deserialized to int32. If the value is out of range
             *    for the target type it will return an error.
             *  - &lt;struct&gt; will be deserialized to "a{sv}". `signature` could define
             *    another value type (e.g. "a{ss}").
             *  - &lt;array&gt; will be deserialized to "av". `signature` could define
             *    another element type (e.g. "as") or could be a tuple (e.g. "(ss)").
             *  - &lt;base64&gt; will be deserialized to "ay".
             *  - &lt;string&gt; will be deserialized to "s".
             *  - &lt;dateTime.iso8601&gt; will be deserialized to an unspecified variant
             *    type. If `signature` is provided it must have the generic "v" type, which
             *    means there is no guarantee that it's actually a datetime that has been
             *    received. soup_xmlrpc_variant_get_datetime() must be used to parse and
             *    type check this special variant.
             *  - `signature` must not have maybes, otherwise an error is returned.
             *  - Dictionaries must have string keys, otherwise an error is returned.
             * @param signature A valid #GVariant type string, or %NULL
             * @returns a new (non-floating) #GVariant, or %NULL
             */
            parse(signature?: string | null): GLib.Variant;
        }

        namespace PasswordManager {
            /**
             * Interface for implementing PasswordManager.
             * Contains only the virtual methods that need to be implemented.
             */
            interface Interface extends SessionFeature.Interface {
                // Virtual methods

                vfunc_get_passwords_async(
                    msg: Message,
                    auth: Auth,
                    retrying: boolean,
                    async_context: GLib.MainContext,
                    cancellable: Gio.Cancellable | null,
                    callback: PasswordManagerCallback,
                ): void;
                vfunc_get_passwords_sync(msg: Message, auth: Auth, cancellable?: Gio.Cancellable | null): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends SessionFeature.ConstructorProps {}
        }

        export interface PasswordManagerNamespace {
            $gtype: GObject.GType<PasswordManager>;
            prototype: PasswordManager;
        }
        interface PasswordManager extends SessionFeature, PasswordManager.Interface {
            // Methods

            get_passwords_async(
                msg: Message,
                auth: Auth,
                retrying: boolean,
                async_context: GLib.MainContext,
                cancellable: Gio.Cancellable | null,
                callback: PasswordManagerCallback,
            ): void;
            get_passwords_sync(msg: Message, auth: Auth, cancellable?: Gio.Cancellable | null): void;
        }

        export const PasswordManager: PasswordManagerNamespace & {
            new (): PasswordManager; // This allows `obj instanceof PasswordManager`
        };

        namespace ProxyResolver {
            /**
             * Interface for implementing ProxyResolver.
             * Contains only the virtual methods that need to be implemented.
             */
            interface Interface extends SessionFeature.Interface {
                // Virtual methods

                vfunc_get_proxy_async(
                    msg: Message,
                    async_context: GLib.MainContext,
                    cancellable: Gio.Cancellable | null,
                    callback: ProxyResolverCallback,
                ): void;
                vfunc_get_proxy_sync(msg: Message, cancellable: Gio.Cancellable | null): [number, Address];
            }

            // Constructor properties interface

            interface ConstructorProps extends SessionFeature.ConstructorProps {}
        }

        export interface ProxyResolverNamespace {
            $gtype: GObject.GType<ProxyResolver>;
            prototype: ProxyResolver;
        }
        interface ProxyResolver extends SessionFeature, ProxyResolver.Interface {
            // Methods

            get_proxy_async(
                msg: Message,
                async_context: GLib.MainContext,
                cancellable: Gio.Cancellable | null,
                callback: ProxyResolverCallback,
            ): void;
            get_proxy_sync(msg: Message, cancellable: Gio.Cancellable | null): [number, Address];
        }

        export const ProxyResolver: ProxyResolverNamespace & {
            new (): ProxyResolver; // This allows `obj instanceof ProxyResolver`
        };

        namespace ProxyURIResolver {
            /**
             * Interface for implementing ProxyURIResolver.
             * Contains only the virtual methods that need to be implemented.
             */
            interface Interface extends SessionFeature.Interface {
                // Virtual methods

                /**
                 * Asynchronously determines a proxy URI to use for `msg` and calls
                 * `callback`.
                 * @param uri the #SoupURI you want a proxy for
                 * @param async_context the #GMainContext to invoke @callback in
                 * @param cancellable a #GCancellable, or %NULL
                 * @param callback callback to invoke with the proxy address
                 */
                vfunc_get_proxy_uri_async(
                    uri: URI,
                    async_context: GLib.MainContext | null,
                    cancellable: Gio.Cancellable | null,
                    callback: ProxyURIResolverCallback,
                ): void;
                /**
                 * Synchronously determines a proxy URI to use for `uri`. If `uri`
                 * should be sent via proxy, *`proxy_uri` will be set to the URI of the
                 * proxy, else it will be set to %NULL.
                 * @param uri the #SoupURI you want a proxy for
                 * @param cancellable a #GCancellable, or %NULL
                 */
                vfunc_get_proxy_uri_sync(uri: URI, cancellable: Gio.Cancellable | null): [number, URI];
            }

            // Constructor properties interface

            interface ConstructorProps extends SessionFeature.ConstructorProps {}
        }

        export interface ProxyURIResolverNamespace {
            $gtype: GObject.GType<ProxyURIResolver>;
            prototype: ProxyURIResolver;
        }
        interface ProxyURIResolver extends SessionFeature, ProxyURIResolver.Interface {
            // Methods

            /**
             * Asynchronously determines a proxy URI to use for `msg` and calls
             * `callback`.
             * @param uri the #SoupURI you want a proxy for
             * @param async_context the #GMainContext to invoke @callback in
             * @param cancellable a #GCancellable, or %NULL
             * @param callback callback to invoke with the proxy address
             */
            get_proxy_uri_async(
                uri: URI,
                async_context: GLib.MainContext | null,
                cancellable: Gio.Cancellable | null,
                callback: ProxyURIResolverCallback,
            ): void;
            /**
             * Synchronously determines a proxy URI to use for `uri`. If `uri`
             * should be sent via proxy, *`proxy_uri` will be set to the URI of the
             * proxy, else it will be set to %NULL.
             * @param uri the #SoupURI you want a proxy for
             * @param cancellable a #GCancellable, or %NULL
             * @returns %SOUP_STATUS_OK if successful, or a transport-level error.
             */
            get_proxy_uri_sync(uri: URI, cancellable: Gio.Cancellable | null): [number, URI];
        }

        export const ProxyURIResolver: ProxyURIResolverNamespace & {
            new (): ProxyURIResolver; // This allows `obj instanceof ProxyURIResolver`
        };

        namespace SessionFeature {
            /**
             * Interface for implementing SessionFeature.
             * Contains only the virtual methods that need to be implemented.
             */
            interface Interface {
                // Virtual methods

                /**
                 * Adds a "sub-feature" of type `type` to the base feature `feature`.
                 * This is used for features that can be extended with multiple
                 * different types. Eg, the authentication manager can be extended
                 * with subtypes of #SoupAuth.
                 * @param type the #GType of a "sub-feature"
                 */
                vfunc_add_feature(type: GObject.GType): boolean;
                /**
                 * Perform setup when a feature is added to a session
                 * @param session
                 */
                vfunc_attach(session: Session): void;
                /**
                 * Perform cleanup when a feature is removed from a session
                 * @param session
                 */
                vfunc_detach(session: Session): void;
                /**
                 * Tests if `feature` has a "sub-feature" of type `type`. See
                 * soup_session_feature_add_feature().
                 * @param type the #GType of a "sub-feature"
                 */
                vfunc_has_feature(type: GObject.GType): boolean;
                /**
                 * Removes the "sub-feature" of type `type` from the base feature
                 * `feature`. See soup_session_feature_add_feature().
                 * @param type the #GType of a "sub-feature"
                 */
                vfunc_remove_feature(type: GObject.GType): boolean;
                /**
                 * Proxies the session's #SoupSession::request_queued signal
                 * @param session
                 * @param msg
                 */
                vfunc_request_queued(session: Session, msg: Message): void;
                /**
                 * Proxies the session's #SoupSession::request_started signal. Deprecated 2.50. Use #SoupMessage::starting instead.
                 * @param session
                 * @param msg
                 * @param socket
                 */
                vfunc_request_started(session: Session, msg: Message, socket: Socket): void;
                /**
                 * Proxies the session's #SoupSession::request_unqueued signal
                 * @param session
                 * @param msg
                 */
                vfunc_request_unqueued(session: Session, msg: Message): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface SessionFeatureNamespace {
            $gtype: GObject.GType<SessionFeature>;
            prototype: SessionFeature;
        }
        interface SessionFeature extends GObject.Object, SessionFeature.Interface {
            // Methods

            /**
             * Adds a "sub-feature" of type `type` to the base feature `feature`.
             * This is used for features that can be extended with multiple
             * different types. Eg, the authentication manager can be extended
             * with subtypes of #SoupAuth.
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature accepted @type as a subfeature.
             */
            add_feature(type: GObject.GType): boolean;
            attach(session: Session): void;
            detach(session: Session): void;
            /**
             * Tests if `feature` has a "sub-feature" of type `type`. See
             * soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @feature has a subfeature of type @type
             */
            has_feature(type: GObject.GType): boolean;
            /**
             * Removes the "sub-feature" of type `type` from the base feature
             * `feature`. See soup_session_feature_add_feature().
             * @param type the #GType of a "sub-feature"
             * @returns %TRUE if @type was removed from @feature
             */
            remove_feature(type: GObject.GType): boolean;
        }

        export const SessionFeature: SessionFeatureNamespace & {
            new (): SessionFeature; // This allows `obj instanceof SessionFeature`
        };

        /**
         * Name of the imported GIR library
         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
         */
        const __name__: string;
        /**
         * Version of the imported GIR library
         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
         */
        const __version__: string;
    }

    export default Soup;
}

declare module 'gi://Soup' {
    import Soup24 from 'gi://Soup?version=2.4';
    export default Soup24;
}
// END
