@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtksource/buffer.js

@@ -4,6 +4,78 @@ import { Language } from "./language.js";
 import { Mark } from "./mark.js";
 import { StyleScheme } from "./style-scheme.js";
 import * as Gtk from "../gtk/index.js";
+/**
+ * Subclass of [class@Gtk.TextBuffer].
+ *
+ * A `GtkSourceBuffer` object is the model for [class@View] widgets.
+ * It extends the [class@Gtk.TextBuffer] class by adding features useful to display
+ * and edit source code such as syntax highlighting and bracket matching.
+ *
+ * To create a `GtkSourceBuffer` use [ctor@GtkSource.Buffer.new] or
+ * [ctor@GtkSource.Buffer.new_with_language]. The second form is just a convenience
+ * function which allows you to initially set a [class@Language]. You can also
+ * directly create a [class@View] and get its [class@Buffer] with
+ * [method@Gtk.TextView.get_buffer].
+ *
+ * The highlighting is enabled by default, but you can disable it with
+ * [method@Buffer.set_highlight_syntax].
+ *
+ * # Context Classes:
+ *
+ * It is possible to retrieve some information from the syntax highlighting
+ * engine. The default context classes that are applied to regions of a
+ * `GtkSourceBuffer`:
+ *
+ * - **comment**: the region delimits a comment;
+ * - **no-spell-check**: the region should not be spell checked;
+ * - **path**: the region delimits a path to a file;
+ * - **string**: the region delimits a string.
+ *
+ * Custom language definition files can create their own context classes,
+ * since the functions like [method@Buffer.iter_has_context_class] take
+ * a string parameter as the context class.
+ *
+ * `GtkSourceBuffer` provides an API to access the context classes:
+ * [method@Buffer.iter_has_context_class],
+ * [method@Buffer.get_context_classes_at_iter],
+ * [method@Buffer.iter_forward_to_context_class_toggle] and
+ * [method@Buffer.iter_backward_to_context_class_toggle].
+ *
+ * And the [signal@GtkSource.Buffer::highlight-updated] signal permits to be notified
+ * when a context class region changes.
+ *
+ * Each context class has also an associated [class@Gtk.TextTag] with the name
+ * `gtksourceview:context-classes:<name>`. For example to
+ * retrieve the [class@Gtk.TextTag] for the string context class, one can write:
+ * ```c
+ * GtkTextTagTable *tag_table;
+ * GtkTextTag *tag;
+ *
+ * tag_table = gtk_text_buffer_get_tag_table (buffer);
+ * tag = gtk_text_tag_table_lookup (tag_table, "gtksourceview:context-classes:string");
+ * ```
+ * ```python
+ * buffer = GtkSource.Buffer()
+ *
+ * tag_table = buffer.get_tag_table()
+ * tag = tag_table.lookup(name="gtksourceview:context-classes:string")
+ * ```
+ *
+ * The tag must be used for read-only purposes.
+ *
+ * Accessing a context class via the associated [class@Gtk.TextTag] is less
+ * convenient than the `GtkSourceBuffer` API, because:
+ *
+ * - The tag doesn't always exist, you need to listen to the
+ * [signal@Gtk.TextTagTable::tag-added] and [signal@Gtk.TextTagTable::tag-removed] signals.
+ * - Instead of the [signal@GtkSource.Buffer::highlight-updated] signal, you can listen
+ * to the [signal@Gtk.TextBuffer::apply-tag] and [signal@Gtk.TextBuffer::remove-tag] signals.
+ *
+ * A possible use-case for accessing a context class via the associated
+ * [class@Gtk.TextTag] is to read the region but without adding a hard dependency on the
+ * GtkSourceView library (for example for a spell-checking library that wants to
+ * read the no-spell-check region).
+ */
 const SIGNAL_META = {
     "bracket-matched": {
         params: [
@@ -31,6 +103,13 @@ export class Buffer extends Gtk.TextBuffer {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new source buffer using the highlighting patterns in `language`.
+     *
+     * This is equivalent to creating a new source buffer with
+     * a new tag table and then calling [method@Buffer.set_language].
+     * @param language - a #GtkSourceLanguage.
+     */
     static bufferNewWithLanguage(language) {
         const ptr = call("libgtksourceview-5.so.0", "gtk_source_buffer_new_with_language", [
             {
@@ -50,6 +129,15 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Moves `iter` to the position of the previous [class@Mark] of the given
+     * category.
+     *
+     * Returns %TRUE if `iter` was moved. If `category` is NULL, the
+     * previous source mark can be of any category.
+     * @param iter - an iterator.
+     * @param category - category to search for, or %NULL
+     */
     backwardIterToSourceMark(iter, category) {
         return call("libgtksourceview-5.so.0", "gtk_source_buffer_backward_iter_to_source_mark", [
             {
@@ -74,6 +162,15 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Changes the case of the text between the specified iterators.
+     *
+     * Since 5.4, this function will update the position of `start` and
+     * `end` to surround the modified text.
+     * @param caseType - how to change the case.
+     * @param start - a #GtkTextIter.
+     * @param end - a #GtkTextIter.
+     */
     changeCase(caseType, start, end) {
         call("libgtksourceview-5.so.0", "gtk_source_buffer_change_case", [
             {
@@ -104,6 +201,26 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Creates a source mark in the `buffer` of category `category`.
+     *
+     * A source mark is a [class@Gtk.TextMark] but organized into categories.
+     * Depending on the category a pixbuf can be specified that will be displayed
+     * along the line of the mark.
+     *
+     * Like a [class@Gtk.TextMark], a [class@Mark] can be anonymous if the
+     * passed `name` is %NULL.  Also, the buffer owns the marks so you
+     * shouldn't unreference it.
+     *
+     * Marks always have left gravity and are moved to the beginning of
+     * the line when the user deletes the line they were in.
+     *
+     * Typical uses for a source mark are bookmarks, breakpoints, current
+     * executing instruction indication in a source file, etc..
+     * @param name - the name of the mark, or %NULL.
+     * @param category - a string defining the mark category.
+     * @param where - location to place the mark.
+     */
     createSourceMark(category, where, name) {
         const ptr = call("libgtksourceview-5.so.0", "gtk_source_buffer_create_source_mark", [
             {
@@ -131,6 +248,17 @@ export class Buffer extends Gtk.TextBuffer {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Mark);
     }
+    /**
+     * Forces buffer to analyze and highlight the given area synchronously.
+     *
+     * **Note**:
+     *
+     * This is a potentially slow operation and should be used only
+     * when you need to make sure that some text not currently
+     * visible is highlighted, for instance before printing.
+     * @param start - start of the area to highlight.
+     * @param end - end of the area to highlight.
+     */
     ensureHighlight(start, end) {
         call("libgtksourceview-5.so.0", "gtk_source_buffer_ensure_highlight", [
             {
@@ -157,6 +285,15 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Moves `iter` to the position of the next [class@Mark] of the given
+     * `category`.
+     *
+     * Returns %TRUE if `iter` was moved. If `category` is NULL, the
+     * next source mark can be of any category.
+     * @param iter - an iterator.
+     * @param category - category to search for, or %NULL
+     */
     forwardIterToSourceMark(iter, category) {
         return call("libgtksourceview-5.so.0", "gtk_source_buffer_forward_iter_to_source_mark", [
             {
@@ -181,6 +318,12 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Get all defined context classes at @iter.
+     *
+     * See the [class@Buffer] description for the list of default context classes.
+     * @param iter - a #GtkTextIter.
+     */
     getContextClassesAtIter(iter) {
         return call("libgtksourceview-5.so.0", "gtk_source_buffer_get_context_classes_at_iter", [
             {
@@ -198,6 +341,10 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "array", itemType: { type: "string" } });
     }
+    /**
+     * Determines whether bracket match highlighting is activated for the
+     * source buffer.
+     */
     getHighlightMatchingBrackets() {
         return call("libgtksourceview-5.so.0", "gtk_source_buffer_get_highlight_matching_brackets", [
             {
@@ -206,6 +353,10 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether syntax highlighting is activated in the source
+     * buffer.
+     */
     getHighlightSyntax() {
         return call("libgtksourceview-5.so.0", "gtk_source_buffer_get_highlight_syntax", [
             {
@@ -222,6 +373,12 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the [class@Language] associated with the buffer,
+     * see [method@Buffer.set_language].
+     *
+     * The returned object should not be unreferenced by the user.
+     */
     getLanguage() {
         const ptr = call("libgtksourceview-5.so.0", "gtk_source_buffer_get_language", [
             {
@@ -241,6 +398,17 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the text in the specified range converting any text formatting
+     * to equivalent Pango markup tags.
+     * This allows the styled text to be displayed in other widgets that support
+     * Pango markup, such as #GtkLabel.
+     *
+     * For very long ranges this function can take long enough that you could
+     * potentially miss frame renderings.
+     * @param start - start of range as a #GtkTextIter
+     * @param end - end of range as a #GtkTextIter
+     */
     getMarkup(start, end) {
         return call("libgtksourceview-5.so.0", "gtk_source_buffer_get_markup", [
             {
@@ -267,6 +435,13 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "string" });
     }
+    /**
+     * Returns the list of marks of the given category at @iter.
+     *
+     * If `category` is %NULL it returns all marks at @iter.
+     * @param iter - an iterator.
+     * @param category - category to search for, or %NULL
+     */
     getSourceMarksAtIter(iter, category) {
         const ptrs = call("libgtksourceview-5.so.0", "gtk_source_buffer_get_source_marks_at_iter", [
             {
@@ -295,6 +470,13 @@ export class Buffer extends Gtk.TextBuffer {
         });
         return ptrs.map((ptr) => getObject(ptr, Mark));
     }
+    /**
+     * Returns the list of marks of the given category at @line.
+     *
+     * If `category` is %NULL, all marks at `line` are returned.
+     * @param line - a line number.
+     * @param category - category to search for, or %NULL
+     */
     getSourceMarksAtLine(line, category) {
         const ptrs = call("libgtksourceview-5.so.0", "gtk_source_buffer_get_source_marks_at_line", [
             {
@@ -318,6 +500,12 @@ export class Buffer extends Gtk.TextBuffer {
         });
         return ptrs.map((ptr) => getObject(ptr, Mark));
     }
+    /**
+     * Returns the [class@StyleScheme] associated with the buffer,
+     * see [method@Buffer.set_style_scheme].
+     *
+     * The returned object should not be unreferenced by the user.
+     */
     getStyleScheme() {
         const ptr = call("libgtksourceview-5.so.0", "gtk_source_buffer_get_style_scheme", [
             {
@@ -329,6 +517,18 @@ export class Buffer extends Gtk.TextBuffer {
             return null;
         return getObject(ptr, StyleScheme);
     }
+    /**
+     * Moves backward to the next toggle (on or off) of the context class.
+     *
+     * If no matching context class toggles are found, returns %FALSE, otherwise %TRUE.
+     * Does not return toggles located at @iter, only toggles after @iter. Sets
+     * `iter` to the location of the toggle, or to the end of the buffer if no
+     * toggle is found.
+     *
+     * See the [class@Buffer] description for the list of default context classes.
+     * @param iter - a #GtkTextIter.
+     * @param contextClass - the context class.
+     */
     iterBackwardToContextClassToggle(iter, contextClass) {
         return call("libgtksourceview-5.so.0", "gtk_source_buffer_iter_backward_to_context_class_toggle", [
             {
@@ -352,6 +552,18 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves forward to the next toggle (on or off) of the context class.
+     *
+     * If no matching context class toggles are found, returns %FALSE, otherwise %TRUE.
+     * Does not return toggles located at @iter, only toggles after @iter. Sets
+     * `iter` to the location of the toggle, or to the end of the buffer if no
+     * toggle is found.
+     *
+     * See the [class@Buffer] description for the list of default context classes.
+     * @param iter - a #GtkTextIter.
+     * @param contextClass - the context class.
+     */
     iterForwardToContextClassToggle(iter, contextClass) {
         return call("libgtksourceview-5.so.0", "gtk_source_buffer_iter_forward_to_context_class_toggle", [
             {
@@ -375,6 +587,13 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Check if the class `context_class` is set on @iter.
+     *
+     * See the [class@Buffer] description for the list of default context classes.
+     * @param iter - a #GtkTextIter.
+     * @param contextClass - class to search for.
+     */
     iterHasContextClass(iter, contextClass) {
         return call("libgtksourceview-5.so.0", "gtk_source_buffer_iter_has_context_class", [
             {
@@ -396,6 +615,11 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Joins the lines of text between the specified iterators.
+     * @param start - a #GtkTextIter.
+     * @param end - a #GtkTextIter.
+     */
     joinLines(start, end) {
         call("libgtksourceview-5.so.0", "gtk_source_buffer_join_lines", [
             {
@@ -422,6 +646,14 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Remove all marks of `category` between `start` and `end` from the buffer.
+     *
+     * If `category` is NULL, all marks in the range will be removed.
+     * @param start - a #GtkTextIter.
+     * @param end - a #GtkTextIter.
+     * @param category - category to search for, or %NULL.
+     */
     removeSourceMarks(start, end, category) {
         call("libgtksourceview-5.so.0", "gtk_source_buffer_remove_source_marks", [
             {
@@ -453,6 +685,14 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Controls the bracket match highlighting function in the buffer.
+     *
+     * If activated, when you position your cursor over a bracket character
+     * (a parenthesis, a square bracket, etc.) the matching opening or
+     * closing bracket character will be highlighted.
+     * @param highlight - %TRUE if you want matching brackets highlighted.
+     */
     setHighlightMatchingBrackets(highlight) {
         call("libgtksourceview-5.so.0", "gtk_source_buffer_set_highlight_matching_brackets", [
             {
@@ -465,6 +705,17 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Controls whether syntax is highlighted in the buffer.
+     *
+     * If `highlight` is %TRUE, the text will be highlighted according to the syntax
+     * patterns specified in the [class@Language] set with [method@Buffer.set_language].
+     *
+     * If `highlight` is %FALSE, syntax highlighting is disabled and all the
+     * [class@Gtk.TextTag] objects that have been added by the syntax highlighting engine
+     * are removed from the buffer.
+     * @param highlight - %TRUE to enable syntax highlighting, %FALSE to disable it.
+     */
     setHighlightSyntax(highlight) {
         call("libgtksourceview-5.so.0", "gtk_source_buffer_set_highlight_syntax", [
             {
@@ -477,6 +728,24 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the `buffer` has an implicit trailing newline.
+     *
+     * If an explicit trailing newline is present in a [class@Gtk.TextBuffer], [class@Gtk.TextView]
+     * shows it as an empty line. This is generally not what the user expects.
+     *
+     * If `implicit_trailing_newline` is %TRUE (the default value):
+     * - when a [class@FileLoader] loads the content of a file into the @buffer,
+     * the trailing newline (if present in the file) is not inserted into the
+     * @buffer.
+     * - when a [class@FileSaver] saves the content of the `buffer` into a file, a
+     * trailing newline is added to the file.
+     *
+     * On the other hand, if `implicit_trailing_newline` is %FALSE, the file's
+     * content is not modified when loaded into the @buffer, and the @buffer's
+     * content is not modified when saved into a file.
+     * @param implicitTrailingNewline - the new value.
+     */
     setImplicitTrailingNewline(implicitTrailingNewline) {
         call("libgtksourceview-5.so.0", "gtk_source_buffer_set_implicit_trailing_newline", [
             {
@@ -489,6 +758,16 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Associates a [class@Language] with the buffer.
+     *
+     * Note that a [class@Language] affects not only the syntax highlighting, but
+     * also the context classes. If you want to disable just the
+     * syntax highlighting, see [method@Buffer.set_highlight_syntax].
+     *
+     * The buffer holds a reference to @language.
+     * @param language - a #GtkSourceLanguage to set, or %NULL.
+     */
     setLanguage(language) {
         call("libgtksourceview-5.so.0", "gtk_source_buffer_set_language", [
             {
@@ -502,6 +781,22 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a [class@StyleScheme] to be used by the buffer and the view.
+     *
+     * Note that a [class@StyleScheme] affects not only the syntax highlighting,
+     * but also other [class@View] features such as highlighting the current line,
+     * matching brackets, the line numbers, etc.
+     *
+     * Instead of setting a %NULL @scheme, it is better to disable syntax
+     * highlighting with [method@Buffer.set_highlight_syntax], and setting the
+     * [class@StyleScheme] with the "classic" or "tango" ID, because those two
+     * style schemes follow more closely the GTK theme (for example for the
+     * background color).
+     *
+     * The buffer holds a reference to @scheme.
+     * @param scheme - a #GtkSourceStyleScheme or %NULL.
+     */
     setStyleScheme(scheme) {
         call("libgtksourceview-5.so.0", "gtk_source_buffer_set_style_scheme", [
             {
@@ -515,6 +810,13 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sort the lines of text between the specified iterators.
+     * @param start - a #GtkTextIter.
+     * @param end - a #GtkTextIter.
+     * @param flags - #GtkSourceSortFlags specifying how the sort should behave
+     * @param column - sort considering the text starting at the given column
+     */
     sortLines(start, end, flags, column) {
         call("libgtksourceview-5.so.0", "gtk_source_buffer_sort_lines", [
             {

package/dist/generated/gtksource/completion-cell.d.ts

@@ -4,15 +4,39 @@ import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
 import * as Gtk from "../gtk/index.js";
 import * as Pango from "../pango/index.js";
+/**
+ * Widget for single cell of completion proposal.
+ *
+ * The `GtkSourceCompletionCell` widget provides a container to display various
+ * types of information with the completion display.
+ *
+ * Each proposal may consist of multiple cells depending on the complexity of
+ * the proposal. For example, programming language proposals may contain a cell
+ * for the "left-hand-side" of an operation along with the "typed-text" for a
+ * function name and "parameters". They may also optionally set an icon to
+ * signify the kind of result.
+ *
+ * A [iface@CompletionProvider] should implement the
+ * [vfunc@CompletionProvider.display] virtual function to control
+ * how to convert data from their [iface@CompletionProposal] to content for
+ * the `GtkSourceCompletionCell`.
+ */
 export declare class CompletionCell extends Gtk.Widget {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     getColumn(): CompletionColumn;
+    /**
+     * Gets the child #GtkWidget, if any.
+     */
     getWidget(): Gtk.Widget | null;
     setGicon(gicon: Gio.Icon): void;
     setIconName(iconName: string): void;
     setMarkup(markup: string): void;
     setPaintable(paintable: Gdk.Paintable): void;
+    /**
+     * Sets the text for the column cell. Use %NULL to unset.
+     * @param text - the text to set or %NULL
+     */
     setText(text?: string | null): void;
     setTextWithAttributes(text: string, attrs: Pango.AttrList): void;
     setWidget(child: Gtk.Widget): void;

package/dist/generated/gtksource/completion-cell.js

@@ -1,6 +1,23 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as Gtk from "../gtk/index.js";
+/**
+ * Widget for single cell of completion proposal.
+ *
+ * The `GtkSourceCompletionCell` widget provides a container to display various
+ * types of information with the completion display.
+ *
+ * Each proposal may consist of multiple cells depending on the complexity of
+ * the proposal. For example, programming language proposals may contain a cell
+ * for the "left-hand-side" of an operation along with the "typed-text" for a
+ * function name and "parameters". They may also optionally set an icon to
+ * signify the kind of result.
+ *
+ * A [iface@CompletionProvider] should implement the
+ * [vfunc@CompletionProvider.display] virtual function to control
+ * how to convert data from their [iface@CompletionProposal] to content for
+ * the `GtkSourceCompletionCell`.
+ */
 export class CompletionCell extends Gtk.Widget {
     constructor(...args) {
         super(...args);
@@ -20,6 +37,9 @@ export class CompletionCell extends Gtk.Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the child #GtkWidget, if any.
+     */
     getWidget() {
         const ptr = call("libgtksourceview-5.so.0", "gtk_source_completion_cell_get_widget", [
             {
@@ -79,6 +99,10 @@ export class CompletionCell extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the text for the column cell. Use %NULL to unset.
+     * @param text - the text to set or %NULL
+     */
     setText(text) {
         call("libgtksourceview-5.so.0", "gtk_source_completion_cell_set_text", [
             {

package/dist/generated/gtksource/completion-context.d.ts

@@ -11,17 +11,81 @@ import * as Gtk from "../gtk/index.js";
 export declare class CompletionContext extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the mode for which the context was activated.
+     */
     getActivation(): CompletionActivation;
+    /**
+     * Gets the bounds for the completion, which is the beginning of the
+     * current word (taking break characters into account) to the current
+     * insertion cursor.
+     *
+     * If `begin` is non-%NULL, it will be set to the start position of the
+     * current word being completed.
+     *
+     * If `end` is non-%NULL, it will be set to the insertion cursor for the
+     * current word being completed.
+     * @param begin - a #GtkTextIter
+     * @param end - a #GtkTextIter
+     */
     getBounds(begin?: Ref<Gtk.TextIter> | null, end?: Ref<Gtk.TextIter> | null): boolean;
+    /**
+     * Gets the underlying buffer used by the context.
+     *
+     * This is a convenience function to get the buffer via the #GtkSourceCompletion
+     * property.
+     */
     getBuffer(): Buffer | null;
+    /**
+     * Gets the "busy" property. This is set to %TRUE while the completion
+     * context is actively fetching proposals from registered
+     * #GtkSourceCompletionProvider's.
+     */
     getBusy(): boolean;
+    /**
+     * Gets the #GtkSourceCompletion that created the context.
+     */
     getCompletion(): Completion | null;
+    /**
+     * Checks if any proposals have been provided to the context.
+     *
+     * Out of convenience, this function will return %TRUE if `self` is %NULL.
+     */
     getEmpty(): boolean;
+    /**
+     * Gets the language of the underlying buffer, if any.
+     */
     getLanguage(): Language | null;
+    /**
+     * Gets the #GListModel associated with the provider.
+     *
+     * You can connect to #GtkSourceCompletionContext::model-changed to receive
+     * notifications about when the model has been replaced by a new model.
+     * @param provider - a #GtkSourceCompletionProvider
+     */
     getProposalsForProvider(provider: CompletionProvider): Gio.ListModel | null;
+    /**
+     * Gets the text view for the context.
+     */
     getView(): View | null;
+    /**
+     * Gets the word that is being completed up to the position of the insert mark.
+     */
     getWord(): string;
+    /**
+     * Gets the providers that are associated with the context.
+     */
     listProviders(): Gio.ListModel;
+    /**
+     * This function allows providers to update their results for a context
+     * outside of a call to [method@CompletionProvider.populate_async].
+     *
+     * This can be used to immediately return results for a provider while it does
+     * additional asynchronous work. Doing so will allow the completions to
+     * update while the operation is in progress.
+     * @param provider - an #GtkSourceCompletionProvider
+     * @param results - a #GListModel or %NULL
+     */
     setProposalsForProvider(provider: CompletionProvider, results?: Gio.ListModel | null): void;
     connect(signal: "provider-model-changed", handler: (self: CompletionContext, provider: CompletionProvider, model: Gio.ListModel) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CompletionContext, pspec: GObject.ParamSpec) => void, after?: boolean): number;