@gtkx/ffi 0.8.0 → 0.9.0

package/dist/generated/soup/auth-domain-digest.d.ts

@@ -30,23 +30,6 @@ export declare class AuthDomainDigest extends AuthDomain {
      * @param password - the password for `username` in @realm
      */
     static encodePassword(username: string, realm: string, password: string): string;
-    /**
-     * 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
-     * [property@AuthDomainDigest:auth-callback] and
-     * [property@AuthDomainDigest:auth-data] properties, which can also be used to
-     * set the callback at construct time.
-     * @param callback - the callback
-     * @param userData - data to pass to @auth_callback
-     * @param dnotify - destroy notifier to free `user_data` when `domain`   is destroyed
-     */
-    setAuthCallback(callback: (...args: unknown[]) => unknown, dnotify: () => void, userData?: number | null): void;
     connect(signal: "notify", handler: (self: AuthDomainDigest, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/soup/auth-domain-digest.js

@@ -63,43 +63,6 @@ export class AuthDomainDigest extends AuthDomain {
             },
         ], { type: "string" });
     }
-    /**
-     * 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
-     * [property@AuthDomainDigest:auth-callback] and
-     * [property@AuthDomainDigest:auth-data] properties, which can also be used to
-     * set the callback at construct time.
-     * @param callback - the callback
-     * @param userData - data to pass to @auth_callback
-     * @param dnotify - destroy notifier to free `user_data` when `domain`   is destroyed
-     */
-    setAuthCallback(callback, dnotify, userData) {
-        call("libsoup-3.0.so.0", "soup_auth_domain_digest_set_auth_callback", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: dnotify,
-            },
-        ], { type: "undefined" });
-    }
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];

package/dist/generated/soup/auth-domain.d.ts

@@ -96,50 +96,6 @@ export declare class AuthDomain extends GObject.GObject {
      * @param path - the path to remove from @domain
      */
     removePath(path: string): void;
-    /**
-     * 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 SoupAuthDomain:filter
-     * and [property@AuthDomain:filter-data properties], which can also be
-     * used to set the filter at construct time.
-     * @param filter - the auth filter for @domain
-     * @param filterData - data to pass to @filter
-     * @param dnotify - destroy notifier to free `filter_data` when `domain`   is destroyed
-     */
-    setFilter(filter: (...args: unknown[]) => unknown, dnotify: () => void, filterData?: number | null): 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, [callback@AuthDomainDigestAuthCallback]),
-     * the generic auth callback will be invoked. See
-     * [callback@AuthDomainGenericAuthCallback] for information on what the callback
-     * should do.
-     * @param authCallback - the auth callback
-     * @param authData - data to pass to @auth_callback
-     * @param dnotify - destroy notifier to free `auth_data` when `domain`   is destroyed
-     */
-    setGenericAuthCallback(authCallback: (...args: unknown[]) => unknown, dnotify: () => void, authData?: number | null): void;
     connect(signal: "notify", handler: (self: AuthDomain, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/soup/auth-domain.js

@@ -181,90 +181,6 @@ export class AuthDomain extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
-    /**
-     * 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 SoupAuthDomain:filter
-     * and [property@AuthDomain:filter-data properties], which can also be
-     * used to set the filter at construct time.
-     * @param filter - the auth filter for @domain
-     * @param filterData - data to pass to @filter
-     * @param dnotify - destroy notifier to free `filter_data` when `domain`   is destroyed
-     */
-    setFilter(filter, dnotify, filterData) {
-        call("libsoup-3.0.so.0", "soup_auth_domain_set_filter", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "callback" },
-                value: filter,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: filterData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: dnotify,
-            },
-        ], { type: "undefined" });
-    }
-    /**
-     * 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, [callback@AuthDomainDigestAuthCallback]),
-     * the generic auth callback will be invoked. See
-     * [callback@AuthDomainGenericAuthCallback] for information on what the callback
-     * should do.
-     * @param authCallback - the auth callback
-     * @param authData - data to pass to @auth_callback
-     * @param dnotify - destroy notifier to free `auth_data` when `domain`   is destroyed
-     */
-    setGenericAuthCallback(authCallback, dnotify, authData) {
-        call("libsoup-3.0.so.0", "soup_auth_domain_set_generic_auth_callback", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "callback" },
-                value: authCallback,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: authData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: dnotify,
-            },
-        ], { type: "undefined" });
-    }
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];

package/dist/generated/soup/logger.d.ts

@@ -80,38 +80,6 @@ export declare class Logger extends GObject.GObject {
      * @param maxBodySize - the maximum body size to log
      */
     setMaxBodySize(maxBodySize: number): void;
-    /**
-     * Sets up an alternate log printing routine, if you don't want
-     * the log to go to `stdout`.
-     * @param printer - the callback for printing logging output
-     * @param printerData - data to pass to the callback
-     * @param destroy - a #GDestroyNotify to free @printer_data
-     */
-    setPrinter(printer: (...args: unknown[]) => unknown, destroy: () => void, printerData?: number | null): 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 [ctor@Logger.new].)
-     * @param requestFilter - the callback for request debugging
-     * @param filterData - data to pass to the callback
-     * @param destroy - a #GDestroyNotify to free @filter_data
-     */
-    setRequestFilter(requestFilter: (...args: unknown[]) => unknown, destroy: () => void, filterData?: number | null): 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 [ctor@Logger.new].)
-     * @param responseFilter - the callback for response debugging
-     * @param filterData - data to pass to the callback
-     * @param destroy - a #GDestroyNotify to free @filter_data
-     */
-    setResponseFilter(responseFilter: (...args: unknown[]) => unknown, destroy: () => void, filterData?: number | null): void;
     connect(signal: "notify", handler: (self: Logger, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/soup/logger.js

@@ -117,98 +117,6 @@ export class Logger extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
-    /**
-     * Sets up an alternate log printing routine, if you don't want
-     * the log to go to `stdout`.
-     * @param printer - the callback for printing logging output
-     * @param printerData - data to pass to the callback
-     * @param destroy - a #GDestroyNotify to free @printer_data
-     */
-    setPrinter(printer, destroy, printerData) {
-        call("libsoup-3.0.so.0", "soup_logger_set_printer", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "callback" },
-                value: printer,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: printerData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: destroy,
-            },
-        ], { type: "undefined" });
-    }
-    /**
-     * 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 [ctor@Logger.new].)
-     * @param requestFilter - the callback for request debugging
-     * @param filterData - data to pass to the callback
-     * @param destroy - a #GDestroyNotify to free @filter_data
-     */
-    setRequestFilter(requestFilter, destroy, filterData) {
-        call("libsoup-3.0.so.0", "soup_logger_set_request_filter", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "callback" },
-                value: requestFilter,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: filterData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: destroy,
-            },
-        ], { type: "undefined" });
-    }
-    /**
-     * 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 [ctor@Logger.new].)
-     * @param responseFilter - the callback for response debugging
-     * @param filterData - data to pass to the callback
-     * @param destroy - a #GDestroyNotify to free @filter_data
-     */
-    setResponseFilter(responseFilter, destroy, filterData) {
-        call("libsoup-3.0.so.0", "soup_logger_set_response_filter", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "callback" },
-                value: responseFilter,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: filterData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: destroy,
-            },
-        ], { type: "undefined" });
-    }
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];

package/dist/generated/soup/message-headers.d.ts

@@ -39,23 +39,6 @@ export declare class MessageHeaders {
      * Clears @hdrs.
      */
     clear(): void;
-    /**
-     * Calls `func` once for each header value in @hdrs.
-     *
-     * Beware that unlike [method@MessageHeaders.get_list], 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
-     * [method@MessageHeaders.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
-     * @param userData - data to pass to @func
-     */
-    foreach(func: (...args: unknown[]) => unknown, userData?: number | null): void;
     /**
      * Frees the array of ranges returned from [method@MessageHeaders.get_ranges].
      * @param ranges - an array of #SoupRange

package/dist/generated/soup/message-headers.js

@@ -89,44 +89,6 @@ export class MessageHeaders {
             },
         ], { type: "undefined" });
     }
-    /**
-     * Calls `func` once for each header value in @hdrs.
-     *
-     * Beware that unlike [method@MessageHeaders.get_list], 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
-     * [method@MessageHeaders.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
-     * @param userData - data to pass to @func
-     */
-    foreach(func, userData) {
-        call("libsoup-3.0.so.0", "soup_message_headers_foreach", [
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "SoupMessageHeaders",
-                    lib: "libsoup-3.0.so.0",
-                },
-                value: this.id,
-            },
-            {
-                type: { type: "callback" },
-                value: func,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Frees the array of ranges returned from [method@MessageHeaders.get_ranges].
      * @param ranges - an array of #SoupRange

package/dist/generated/soup/server.d.ts

@@ -29,78 +29,6 @@ export declare class Server extends GObject.GObject {
      * @param authDomain - a #SoupAuthDomain
      */
     addAuthDomain(authDomain: AuthDomain): void;
-    /**
-     * Adds an "early" handler to `server` for requests prefixed by @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 [class@AuthDomain] or a signal handler), `callback` will be invoked after receiving the request headers, but before
-     * receiving the request body; the message's method and
-     * request-headers properties will be set.
-     *
-     * 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 [method@MessageBody.set_accumulate] on
-     * the message's request-body to turn off request-body accumulation, and connect
-     * to the message's [signal@ServerMessage::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 [signal@ServerMessage::got-body],
-     * or else you can register a non-early handler for `path` as well. As
-     * long as you have not set the status-code by the time
-     * [signal@ServerMessage::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
-     * @param userData - data for @callback
-     * @param destroy - destroy notifier to free @user_data
-     */
-    addEarlyHandler(callback: (...args: unknown[]) => unknown, destroy: () => void, path?: string | null, userData?: number | null): void;
-    /**
-     * Adds a handler to `server` for requests prefixed by @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 [class@AuthDomain], an early server handler, or a
-     * signal handler), `callback` will be invoked after receiving the
-     * request body; the [class@ServerMessage]'s method, request-headers,
-     * and request-body properties will be set.
-     *
-     * After determining what to do with the request, the callback must at a minimum
-     * call [method@ServerMessage.set_status] 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 [method@ServerMessage.pause]
-     * to tell `server` to not send the response right away. When the
-     * response is ready, call [method@ServerMessage.unpause] to cause it
-     * to be sent.
-     *
-     * To send the response body a bit at a time using "chunked" encoding, first
-     * call [method@MessageHeaders.set_encoding] to set %SOUP_ENCODING_CHUNKED on
-     * the response-headers. Then call [method@MessageBody.append] (or
-     * [method@MessageBody.append_bytes])) to append each chunk as it becomes ready,
-     * and [method@ServerMessage.unpause] 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
-     * [method@MessageBody.complete] to indicate that no more chunks are coming.
-     * @param path - the toplevel path for the handler
-     * @param callback - callback to invoke for
-     * @param userData - data for @callback
-     * @param destroy - destroy notifier to free @user_data
-     */
-    addHandler(callback: (...args: unknown[]) => unknown, destroy: () => void, path?: string | null, userData?: number | null): void;
     /**
      * Add support for a WebSocket extension of the given @extension_type.
      *
@@ -113,33 +41,6 @@ export declare class Server extends GObject.GObject {
      * @param extensionType - a #GType
      */
     addWebsocketExtension(extensionType: number): void;
-    /**
-     * Adds a WebSocket handler to `server` for requests prefixed by @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 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
-     * @param callback - callback to invoke for
-     * @param userData - data for @callback
-     * @param destroy - destroy notifier to free @user_data
-     */
-    addWebsocketHandler(callback: (...args: unknown[]) => unknown, destroy: () => void, path?: string | null, origin?: string | null, protocols?: string[] | null, userData?: number | null): void;
     /**
      * Closes and frees @server's listening sockets.
      *