@girs/cogl-16 5.1.0 → 5.3.0

package/README.md

@@ -4,7 +4,7 @@
 ![version](https://img.shields.io/npm/v/@girs/cogl-16)
 ![downloads/week](https://img.shields.io/npm/dw/@girs/cogl-16)
 
-GJS TypeScript type definitions for Cogl-16 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v5.1.0.
+GJS TypeScript type definitions for Cogl-16 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v5.3.0.
 
 This package contains type declarations only. It ships no runtime code, so it adds
 nothing to your program and works with any bundler or none at all.
@@ -26,6 +26,7 @@ type packages.
 | `@girs/cogl-16/ambient` | only the `gi://` module declarations |
 | `@girs/cogl-16/import` | only the `imports.gi` declarations |
 | `@girs/cogl-16/cogl-16` | the namespace, without the side-effecting declarations |
+| `@girs/cogl-16/vocabulary` | GIR-derived widget data: settable properties, enum nicks, slot candidates |
 
 ## Three ways to import
 
@@ -67,6 +68,24 @@ GJS's global object works the same way, via `@girs/cogl-16/import`:
 const Cogl = imports.gi.Cogl;
 ```
 
+## Widget vocabulary
+
+`cogl-16` declares widgets, so it also carries what the GIR says about them, as
+types and as values a test can read:
+
+```ts
+import type { Widgets, PropsOf } from '@girs/cogl-16/vocabulary';
+import { OWN_PROPS, ENUM_NICKS, PROVENANCE } from '@girs/cogl-16/vocabulary';
+```
+
+Properties are keyed the way GObject registered them, writable-only and optional, so they
+match `g_object_set`, GtkBuilder XML and Blueprint. `PROVENANCE.libraryVersion` names the
+library release this was generated from, which lets a check tell "newer than what is
+installed" from "wrong".
+
+This subpath answers what the GIR says, not what the installed library has. For the
+second question, ask the library.
+
 ## Building
 
 The declarations need no build step. If you bundle, every bundler works, since there is

package/cogl-16-vocabulary.d.ts

@@ -0,0 +1,515 @@
+/**
+ * The GIR-derived widget VOCABULARY for Cogl-16.
+ *
+ * GENERATED — do not edit. Provenance: Cogl-16 — prop(s) no TypeScript value satisfies: Cogl.Framebuffer.driver-config Cogl.Texture.loader
+ *
+ * 24 instantiable GTypes (of which 0 concrete widgets), 27 declarations, 13 enum nick unions, 0 slot candidates.
+ *
+ * Module-scoped exports only. There is no `JSX` namespace here, no tag spelling and
+ * no `on<Signal>` prop name: those are DIALECT, and every framework answers them
+ * differently. The shape to avoid is the GLOBAL AUGMENT — a `declare global` on
+ * `React.JSX` collides with every other library on a shared tag — while a
+ * module-scoped `JSX` behind a `jsxImportSource` does not. This package is used by
+ * projects that want nothing to do with JSX, so it emits neither; a consumer declaring
+ * a module-scoped namespace over these names is doing it right.
+ *
+ * Three things this is and `ConstructorProps` is not: WRITABLE-only (measured on
+ * Gtk-4.0, `ConstructorProps` offers 150 read-only properties across 68 classes as
+ * settable, and GTK's failure mode for writing one is exit 0), OPTIONAL, and keyed
+ * by the name GObject actually REGISTERED — the dashed spelling `g_object_set`,
+ * GtkBuilder XML and Blueprint all use.
+ *
+ * Signal handler types are not re-derived: `X.SignalSignatures`, which this package
+ * already emits for every class with the parent chain, every implemented interface
+ * and the `notify::` keys folded in, is what `Widgets[G]['signals']` points at.
+ */
+
+import type Cogl from './cogl-16.js';
+import type { GObjectConstructOnly, GObjectProps } from '@girs/gobject-2.0/vocabulary';
+
+// ---------------------------------------------------------------------------
+// Enum nicks — the string vocabulary GObject registered, from GIR's `glib:nick`.
+//
+// Not derived from the member name. Substituting underscores for dashes is not a law:
+// some nicks keep an underscore the substitution would have replaced, and only the
+// attribute knows which. Gtk-4.0 and Adw-1 contradict no derivation at all, which is
+// how a derived nick passes review and breaks elsewhere.
+// Re-measure with `scripts/check-nick-derivation.mjs` in ts-for-gir.
+// ---------------------------------------------------------------------------
+
+export type CoglAttributeTypeNick = 'byte' | 'unsigned-byte' | 'short' | 'unsigned-short' | 'float';
+export type CoglBufferBindTargetNick = 'pixel-pack' | 'pixel-unpack' | 'attribute-buffer' | 'index-buffer' | 'count';
+export type CoglBufferUpdateHintNick = 'static' | 'dynamic' | 'stream';
+export type CoglDepthTestFunctionNick = 'never' | 'less' | 'equal' | 'lequal' | 'greater' | 'notequal' | 'gequal' | 'always';
+export type CoglFilterReturnNick = 'continue' | 'remove';
+export type CoglIndicesTypeNick = 'byte' | 'short' | 'int';
+export type CoglPixelFormatNick = 'any' | 'a-8' | 'rgb-565' | 'rgba-4444' | 'rgba-5551' | 'yuv' | 'r-8' | 'rg-88' | 'rgb-888' | 'bgr-888' | 'rgbx-8888' | 'rgba-8888' | 'bgrx-8888' | 'bgra-8888' | 'xrgb-8888' | 'argb-8888' | 'xbgr-8888' | 'abgr-8888' | 'rgba-8888-pre' | 'bgra-8888-pre' | 'argb-8888-pre' | 'abgr-8888-pre' | 'rgba-4444-pre' | 'rgba-5551-pre' | 'rgba-1010102' | 'bgra-1010102' | 'xrgb-2101010' | 'argb-2101010' | 'xbgr-2101010' | 'abgr-2101010' | 'rgba-1010102-pre' | 'bgra-1010102-pre' | 'argb-2101010-pre' | 'abgr-2101010-pre' | 'rgbx-fp-16161616' | 'rgba-fp-16161616' | 'bgrx-fp-16161616' | 'bgra-fp-16161616' | 'xrgb-fp-16161616' | 'argb-fp-16161616' | 'xbgr-fp-16161616' | 'abgr-fp-16161616' | 'rgba-fp-16161616-pre' | 'bgra-fp-16161616-pre' | 'argb-fp-16161616-pre' | 'abgr-fp-16161616-pre' | 'rgba-fp-32323232' | 'rgba-fp-32323232-pre' | 'r-16' | 'rg-1616' | 'rgba-16161616' | 'rgba-16161616-pre' | 'depth-16' | 'depth-24-stencil-8';
+export type CoglRendererErrorNick = 'xlib-display-open' | 'bad-constraint';
+export type CoglShaderTypeNick = 'vertex' | 'fragment';
+export type CoglSystemErrorNick = 'cogl-system-error-unsupported' | 'cogl-system-error-no-memory';
+export type CoglVerticesModeNick = 'points' | 'lines' | 'line-loop' | 'line-strip' | 'triangles' | 'triangle-strip' | 'triangle-fan';
+export type CoglWindingNick = 'clockwise' | 'counter-clockwise';
+export type CoglWinsysFeatureNick = 'vblank-counter' | 'vblank-wait' | 'texture-from-pixmap' | 'swap-buffers-event' | 'swap-region' | 'swap-region-throttle' | 'swap-region-synchronized' | 'buffer-age' | 'sync-and-complete-event' | 'n-features';
+
+// ---------------------------------------------------------------------------
+// Property surfaces — one interface per GIR DECLARATION, mirroring GIR's own
+// inheritance rather than flattening per widget.
+//
+// The interfaces are load-bearing, not tidiness: `GtkBox` declares four properties
+// of its own and `orientation` is not among them — it lives on `Gtk.Orientable`,
+// because GObject installs interface properties on the implementor at runtime while
+// GIR keeps them once, on the interface.
+// ---------------------------------------------------------------------------
+
+export interface CoglAtlasProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglAtlasConstructOnly = GObjectConstructOnly;
+
+/** Functions for managing textures in Cogl's global set of texture atlases A texture atlas is a texture that contains many smaller images that an application is interested in. */
+export interface CoglAtlasTextureProps extends CoglTextureProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglAtlasTextureConstructOnly = CoglTextureConstructOnly;
+
+export interface CoglAttributeProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglAttributeConstructOnly = GObjectConstructOnly;
+
+/** Functions for creating and manipulating attribute buffers */
+export interface CoglAttributeBufferProps extends CoglBufferProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglAttributeBufferConstructOnly = CoglBufferConstructOnly;
+
+/** Functions for loading images Cogl allows loading image data into memory as CoglBitmaps without loading them immediately into GPU textures. */
+export interface CoglBitmapProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglBitmapConstructOnly = GObjectConstructOnly;
+
+/** Common buffer functions, including data upload APIs The CoglBuffer API provides a common interface to manipulate buffers that have been allocated either via `cogl_pixel_buffer_new()` or `cogl_attribu… */
+export interface CoglBufferProps extends GObjectProps {
+    context?: Cogl.Context;
+    /** @default COGL_BUFFER_BIND_TARGET_PIXEL_PACK */
+    'default-target'?: CoglBufferBindTargetNick | Cogl.BufferBindTarget;
+    /** @default 0 */
+    size?: bigint | number;
+    /** @default COGL_BUFFER_UPDATE_HINT_STATIC */
+    'update-hint'?: CoglBufferUpdateHintNick | Cogl.BufferUpdateHint;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglBufferConstructOnly = GObjectConstructOnly | 'context' | 'default-target' | 'size';
+
+/** The top level application context. */
+export interface CoglContextProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglContextConstructOnly = GObjectConstructOnly;
+
+/** Common aspects of a display pipeline The basic intention for this object is to let the application configure common display preferences before creating a context, and there are a few different aspect… */
+export interface CoglDisplayProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglDisplayConstructOnly = GObjectConstructOnly;
+
+/** Frame information. */
+export interface CoglFrameInfoProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglFrameInfoConstructOnly = GObjectConstructOnly;
+
+export interface CoglFramebufferProps extends GObjectProps {
+    context?: Cogl.Context;
+    'driver-config'?: never;
+    /** @default -1 */
+    height?: number;
+    /** @default -1 */
+    width?: number;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglFramebufferConstructOnly = GObjectConstructOnly | 'context' | 'driver-config';
+
+/** Functions for creating and manipulating vertex indices. */
+export interface CoglIndexBufferProps extends CoglBufferProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglIndexBufferConstructOnly = CoglBufferConstructOnly;
+
+/** Describe vertex indices stored in a #CoglIndexBuffer. */
+export interface CoglIndicesProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglIndicesConstructOnly = GObjectConstructOnly;
+
+/** Efficiently tracking many related transformations. */
+export interface CoglMatrixStackProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglMatrixStackConstructOnly = GObjectConstructOnly;
+
+/** Functions for creating and manipulating offscreen framebuffers. */
+export interface CoglOffscreenProps extends CoglFramebufferProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglOffscreenConstructOnly = CoglFramebufferConstructOnly;
+
+export interface CoglOnscreenProps extends CoglFramebufferProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglOnscreenConstructOnly = CoglFramebufferConstructOnly;
+
+/** Functions for creating and manipulating the GPU pipeline Cogl allows creating and manipulating objects representing the full configuration of the GPU pipeline. */
+export interface CoglPipelineProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglPipelineConstructOnly = GObjectConstructOnly;
+
+export interface CoglPixelBufferProps extends CoglBufferProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglPixelBufferConstructOnly = CoglBufferConstructOnly;
+
+/** Functions for creating, manipulating and drawing primitives */
+export interface CoglPrimitiveProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglPrimitiveConstructOnly = GObjectConstructOnly;
+
+export interface CoglProgramProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglProgramConstructOnly = GObjectConstructOnly;
+
+/** Choosing a means to render A #CoglRenderer represents a means to render. */
+export interface CoglRendererProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglRendererConstructOnly = GObjectConstructOnly;
+
+export interface CoglScanoutProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglScanoutConstructOnly = GObjectConstructOnly;
+
+/** Functions for accessing the programmable GL pipeline Cogl allows accessing the GL programmable pipeline in order to create vertex and fragment shaders. */
+export interface CoglShaderProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglShaderConstructOnly = GObjectConstructOnly;
+
+/** Functions for creating and manipulating shader snippets `CoglSnippet`s are used to modify or replace parts of a #CoglPipeline using GLSL. */
+export interface CoglSnippetProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglSnippetConstructOnly = GObjectConstructOnly;
+
+/** Functions for creating and manipulating sub-textures. */
+export interface CoglSubTextureProps extends CoglTextureProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglSubTextureConstructOnly = CoglTextureConstructOnly;
+
+/** Functions for creating and manipulating textures Cogl allows creating and manipulating textures using a uniform API that tries to hide all the various complexities of creating, loading and manipulati… */
+export interface CoglTextureProps extends GObjectProps {
+    context?: Cogl.Context;
+    /** @default COGL_PIXEL_FORMAT_ANY */
+    format?: CoglPixelFormatNick | Cogl.PixelFormat;
+    /** @default -1 */
+    height?: number;
+    loader?: never;
+    /** @default -1 */
+    width?: number;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglTextureConstructOnly = GObjectConstructOnly | 'context' | 'format' | 'height' | 'loader' | 'width';
+
+/** Functions for creating and manipulating 2D textures These functions allow low-level 2D textures to be allocated. */
+export interface CoglTexture2DProps extends CoglTextureProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglTexture2DConstructOnly = CoglTextureConstructOnly;
+
+/** Functions for creating and manipulating 2D meta textures that may internally be comprised of multiple 2D textures with power-of-two sizes. */
+export interface CoglTexture2DSlicedProps extends CoglTextureProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type CoglTexture2DSlicedConstructOnly = CoglTextureConstructOnly;
+
+// ---------------------------------------------------------------------------
+// The GType-keyed widget map.
+//
+// Keyed by GType because that is also the GtkBuilder XML key and the typelib key. A
+// consumer maps GTypes to tags in ITS convention — kebab for JSX intrinsics, Pascal
+// for a Vue `GlobalComponents`, the class itself for a renderer whose element type
+// is the class. None of those is baked in here.
+//
+// `slotCandidates` is a candidate list and never an answer: derived from methods
+// taking exactly one widget argument. The GIR cannot tell adoption from reference —
+// `set_title_widget` parents its argument and `set_activatable_widget` does not, and
+// both are `void f(GtkWidget*)` at `transfer-ownership="none"`. Curation decides;
+// this is what notices when a release adds a candidate.
+// ---------------------------------------------------------------------------
+
+export interface Widgets {
+
+}
+
+/**
+ * Every GType this namespace can create AND put on screen. A consumer derives its own
+ * tag map. For everything a UI file can instantiate — layout managers, event
+ * controllers, cell renderers, `GtkSizeGroup` — read `DECLS` below.
+ */
+export type WidgetGType = keyof Widgets;
+
+// ---------------------------------------------------------------------------
+// Child holders — the same shape, for objects that CARRY a widget without being one.
+//
+// `GtkListItem`, `GtkListHeader`, `GtkColumnViewCell` and `AdwToggle` descend from
+// `GObject.Object` and hold a widget through `set_child`/`get_child`. A renderer places
+// them exactly like a container, so they belong in the vocabulary; a check asking "is
+// this a widget" must still be able to say no. Hence a sibling table rather than four
+// more rows in `Widgets`: concatenate them when you mean both.
+// ---------------------------------------------------------------------------
+
+export interface ChildHolders {
+
+}
+
+/** Every GType this namespace holds a child in without it being a widget. */
+export type ChildHolderGType = keyof ChildHolders;
+
+/** The writable, optional, GObject-keyed property surface of one GType. */
+export type PropsOf<G extends WidgetGType> = Widgets[G]['props'];
+
+/** The signal table this package already emits, reached by GType. */
+export type SignalsOf<G extends WidgetGType> = Widgets[G]['signals'];
+
+/** The instance type — what a `ref`-shaped prop should infer. */
+export type InstanceOf<G extends WidgetGType> = Widgets[G]['class'];
+
+/** Property names that can only be set at construction. */
+export type ConstructOnlyOf<G extends WidgetGType> = Widgets[G]['constructOnly'];
+
+/** Candidate child slots — see the note above; curation decides. */
+export type SlotCandidatesOf<G extends WidgetGType> = keyof Widgets[G]['slotCandidates'];
+
+/**
+ * The same facts as runtime data, for a consumer that CHECKS them.
+ *
+ * Types are erased, so a spec that asks the installed GTK whether every property
+ * here is a writable ParamSpec, every signal resolvable by `GObject.signal_lookup`
+ * and every nick resolvable through an enum lookup cannot read the interfaces
+ * above. Emitted headlessly with no GTK present, which is exactly why the checking
+ * belongs to the consumer and the DATA belongs here.
+ */
+export const PROVENANCE: {
+    readonly namespace: string;
+    readonly version: string;
+    /** The version the LIBRARY states, or null where it states none. Never the namespace's. */
+    readonly libraryVersion: string | null;
+    readonly childHolders: number;
+    readonly droppedBases: readonly string[];
+    readonly inlinedBases: readonly string[];
+    /** `<decl>.<prop>` for every property printed `never` because TypeScript has no value for it. */
+    readonly unsettableProps: readonly string[];
+    /**
+     * `<decl>.<prop>: <Ns>.<Name>` for every property printed `never` because the model
+     * could not resolve its type across a namespace boundary — two independently released
+     * GIRs disagreeing, which is what the main emitter answers `never` for as well.
+     */
+    readonly unresolvedProps: readonly string[];
+    /**
+     * `c:identifier-prefixes` from the GIR, verbatim and in order — `['G']` for Gio.
+     *
+     * The C prefix a type REFERENCE needs: resolving `Gio.Icon` means producing `GIcon`,
+     * and nothing else in this package states that `Gio` spells itself `G`. Carried rather
+     * than derived because GIR carries it, and a derivation over the `DECLS` keys is wrong
+     * wherever the C prefix is not a prefix of the type NAMES: gdkx11-4.0 and gdkwayland-4.0
+     * both state `Gdk` while every key they declare begins `GdkX11`/`GdkWayland`.
+     *
+     * Empty where the GIR states none — 17 of the 627 emitting namespaces — because
+     * inventing the namespace name there is a confident wrong answer in place of a missing
+     * one. A LIST because 20 of them state more than one, which no single string expresses.
+     */
+    readonly identifierPrefixes: readonly string[];
+    /**
+     * Sibling vocabularies this one's DECLARATIONS come from, as import specifiers.
+     *
+     * A chain link with no `OWN_PROPS` row is ambiguous on its own — `GtkSeparator` has no
+     * settable property, `GApplication` has its properties in another package — and this
+     * list is what tells the two apart. Enum and bitfield NUMBERS are not here: those are
+     * carried in this file, because a `PROP_ENUMS` row naming a foreign GType gives a
+     * consumer nothing to load and a `.ui` file using the property never names its owner.
+     */
+    readonly requiredVocabularies: readonly string[];
+};
+
+/** Declaration GType -> its own settable properties, as GObject registered them. */
+export const OWN_PROPS: Readonly<Record<string, readonly string[]>>;
+
+/**
+ * Declaration GType -> the signals it registers itself, never its parents'.
+ *
+ * Keyed like `OWN_PROPS`, so both are read at every link of a `DECLS` chain. An
+ * abstract base has no `Widgets` row and still owns signals — `GtkWidget` owns 13.
+ */
+export const OWN_SIGNALS: Readonly<Record<string, readonly string[]>>;
+
+/**
+ * Instantiable GType -> every declaration its members come from, self first.
+ *
+ * The key set is what a UI description file can NAME: every registered, non-abstract
+ * class this namespace declares. GtkBuilder resolves a `<object class="…">` through
+ * `g_type_from_name`, which knows nothing about widgets, so this is wider than
+ * `Widgets` by design — `GtkSizeGroup`, `GtkTextTag`, every `GtkEventController`
+ * and every `GtkCellRenderer` are here and are not widgets.
+ *
+ * `Widgets` and `CHILD_HOLDERS` are the narrower questions and answer them unchanged.
+ */
+export const DECLS: Readonly<Record<string, readonly string[]>>;
+
+/** The GTypes in `DECLS` that hold a widget without being one — see `ChildHolders`. */
+export const CHILD_HOLDERS: readonly string[];
+
+/** Enum GType -> the nicks this surface offers. */
+export const ENUM_NICKS: Readonly<Record<string, readonly string[]>>;
+
+/**
+ * `<enum GType>.<nick>` -> the integer GObject registers for it, from GIR's `value`.
+ *
+ * Position in `ENUM_NICKS` is NOT this number. Counting is wrong on 6 of the 137 enums a
+ * GTK 4 vocabulary carries -- 112 in Gtk-4.0 and 25 in Adw-1: `GtkResponseType` runs -1 to -11, `GtkTextWindowType` starts
+ * at 1, `GtkOrdering` and `GtkConstraintRelation` are -1/0/1, `GtkAlign` has two names
+ * on one value, and `GtkConstraintStrength.required` is 1001001000 where counting says 0.
+ *
+ * Read from the same GIR as the nicks, deliberately. A consumer reading the numbers off an
+ * installed typelib instead has two provenances for one table, and then cannot tell a
+ * missing number from a host older than the vocabulary.
+ */
+export const ENUM_VALUES: Readonly<Record<string, number>>;
+
+/**
+ * The `<enum GType>.<nick>` entries GIR marks `deprecated="1"`.
+ *
+ * Two names on one value is how GObject spells an alias -- `GTK_ALIGN_BASELINE` and
+ * `GTK_ALIGN_BASELINE_FILL` are both 4, and both keep a `ENUM_VALUES` entry. The pairing
+ * is visible in the numbers; which name is the old one is not, and this is that fact --
+ * where GIR states it. It usually does not: 4 registered-enum members across the 718 GIRs
+ * carry the attribute, and 179 of the 182 value-sharing pairs carry it on neither half, so
+ * absence from this list means GIR is silent, not that the nick is the current one.
+ */
+export const ENUM_DEPRECATED: readonly string[];
+
+/**
+ * `<enum GType>.<nick>` -> the raw GIR `value` no number could be read from.
+ *
+ * The declared remainder, so that every nick in `ENUM_NICKS` is in `ENUM_VALUES` or in
+ * here and a drop cannot be silent. Two shapes reach it: a symbolic or absent value (Vala
+ * writes `(null)`, a char enum writes a letter) and an integer past
+ * `Number.MAX_SAFE_INTEGER`, where a literal would lose precision and stop being the
+ * GIR's number. Empty for Gtk, Adw, GLib and Gio.
+ */
+export const ENUM_VALUES_UNREADABLE: Readonly<Record<string, string>>;
+
+/**
+ * `<bitfield GType>.<nick>` -> the integer GObject registers for that one member.
+ *
+ * `ENUM_NICKS` carries no bitfield, because GObject cannot resolve a nick SET; that says
+ * nothing about a single member's number, and the number is what a host without GI needs.
+ * 23 settable properties in Gtk-4.0 and Adw-1 are bitfield-typed and are declared bare
+ * `number` -- `GtkEntry:input-hints`, `GtkPopoverMenu:flags`, `AdwTabView:shortcuts`,
+ * `GtkDropTarget:actions` among them. Counting is worst here: 119 of the 156 Gtk-4.0
+ * bitfield members this vocabulary carries disagree with their declaration position,
+ * against 29 of 672 enumeration members.
+ *
+ * Combine with `|` as GObject does. There is no nick table to pair this with, so a name
+ * here is resolvable and a SET still is not.
+ */
+export const FLAG_VALUES: Readonly<Record<string, number>>;
+
+/** `<bitfield GType>.<nick>` -> the raw GIR `value` no number could be read from. */
+export const FLAG_VALUES_UNREADABLE: Readonly<Record<string, string>>;
+
+/**
+ * `<declaration GType>.<property>` -> the GType of that property's enum or bitfield.
+ *
+ * The join the value tables need and nothing else here carries. A host with no GI has a
+ * property name and a nick and needs a number; `ENUM_VALUES` is keyed by ENUM GType, and
+ * only this says which enum a property is. Keyed by DECLARATION like `OWN_PROPS`, so it is
+ * read at every link of a `DECLS` chain — `orientation` belongs to `GtkOrientable`, not
+ * to the `GtkBox` a caller starts from.
+ *
+ * Present only where the property's OWN type is the enum: an array of them, or a union that
+ * merely mentions one, would be an entry a consumer resolves wrongly.
+ *
+ * The GType named here is not always one THIS module gives numbers for. A nick vocabulary is
+ * emitted once, by the namespace that owns the enum, so `AdwComboRow.search-match-mode` names
+ * `GtkStringFilterMatchMode` and its rows are in `@girs/gtk-4.0/vocabulary` — 83 of the 909
+ * entries in a full run resolve only with the owner's vocabulary loaded beside this one. An
+ * owner with no vocabulary of its own (Gdk, Pango) is inlined here instead, so every entry
+ * resolves against SOME module.
+ */
+export const PROP_ENUMS: Readonly<Record<string, string>>;
+
+/**
+ * The kinds of value a GTK accessible property, relation or state takes.
+ *
+ * `enum` is the one that needs a second lookup: `ARIA_VALUE_ENUMS` names the enum GType,
+ * and `ENUM_NICKS` and `ENUM_VALUES` answer from there.
+ */
+export type AriaValueType = 'string' | 'integer' | 'double' | 'boolean' | 'reference' | 'enum';
+
+/**
+ * `<enum GType>.<nick>` -> the kind of value that ARIA slot takes.
+ *
+ * The one table in this file that is not a fact about a ParamSpec. A GtkBuilder or
+ * Blueprint `accessibility { … }` block is typed by GTK's ARIA table, not by the widget,
+ * and the two disagree where it costs most: `orientation` is settable on a `GtkLabel`
+ * that implements no `GtkOrientable`, and `checked` is a `GtkAccessibleTristate`, so
+ * `checked: true` is the number 1 rather than a boolean. Typing those slots from the
+ * widget's properties gets both wrong and raises nothing.
+ *
+ * Keyed like `ENUM_VALUES` because the ARIA names ARE enum members — of
+ * `GtkAccessibleProperty`, `GtkAccessibleRelation` and `GtkAccessibleState` — so
+ * `ENUM_NICKS` already lists them and one key parser reads both.
+ *
+ * Read from each member's own GIR documentation. `gtk_accessible_property_init_value()`
+ * is the C half of this table and is not introspectable; the doc sentence is, and states
+ * the type for 52 of the 53 members in gtk4 4.23.3. Complete or absent, never partial: a
+ * member the generator cannot answer for fails the build and names itself.
+ */
+export const ARIA_VALUE_TYPES: Readonly<Record<string, AriaValueType>>;
+
+/**
+ * The same keys, for the `'enum'` rows only -> the GType of that enum.
+ *
+ * A table of its own for the reason `PROP_ENUMS` is one: folded in, the values of
+ * `ARIA_VALUE_TYPES` would be six reserved words mixed with arbitrary GTypes and telling
+ * them apart would be the consumer's problem. Apart, `ARIA_VALUE_TYPES[k] === 'enum'` is
+ * the whole test and `ENUM_NICKS[ARIA_VALUE_ENUMS[k]]` is the nick list.
+ */
+export const ARIA_VALUE_ENUMS: Readonly<Record<string, string>>;
+
+/** Widget GType -> slot name -> the method that may adopt a child there. */
+export const SLOT_CANDIDATES: Readonly<Record<string, Readonly<Record<string, string>>>>;
+
+/**
+ * `Type`, `Type.property` and `Type::signal` -> the release that introduced it.
+ *
+ * What keeps a runtime cross-check honest across a version gap without an
+ * allowlist: a name the installed library lacks is a defect UNLESS the version
+ * here is newer than the one running.
+ *
+ * ALL THREE key shapes, because that test only works for the names it covers. A
+ * property-only map leaves a consumer no way to explain a missing SIGNAL, which is
+ * a correct vocabulary reported as 18 defects; a member-only map leaves it no way to
+ * explain a missing CLASS, and that one fails as a bare
+ * `TypeError: can't access property "$gtype", ctor() is undefined` that does not
+ * even name the GType.
+ *
+ * A key is present only where the GIR states a version — sparse by nature (`version`
+ * sits on 29 of the 301 classes and interfaces in Gtk-4.0), never inferred.
+ */
+export const SINCE: Readonly<Record<string, string>>;

package/cogl-16-vocabulary.js

@@ -0,0 +1,311 @@
+// The widget vocabulary of Cogl-16 as runtime data.
+//
+// GENERATED — do not edit. Provenance: Cogl-16 — prop(s) no TypeScript value satisfies: Cogl.Framebuffer.driver-config Cogl.Texture.loader
+//
+// The type half of this subpath is the sibling `.d.ts`. This file exists because
+// types are erased: a consumer that wants to ask the installed library whether every
+// name here is real needs values, not declarations.
+
+export const PROVENANCE = {
+    namespace: 'Cogl',
+    version: '16',
+    libraryVersion: null,
+    childHolders: 0,
+    droppedBases: [],
+    inlinedBases: [],
+    unsettableProps: ['Cogl.Framebuffer.driver-config', 'Cogl.Texture.loader'],
+    unresolvedProps: [],
+    identifierPrefixes: ['Cogl'],
+    requiredVocabularies: ['@girs/gobject-2.0/vocabulary'],
+};
+
+export const OWN_PROPS = {
+    CoglBuffer: ['context', 'default-target', 'size', 'update-hint'],
+    CoglFramebuffer: ['context', 'driver-config', 'height', 'width'],
+    CoglTexture: ['context', 'format', 'height', 'loader', 'width'],
+};
+
+export const OWN_SIGNALS = {
+    CoglFramebuffer: ['destroy'],
+    CoglScanout: ['scanout-failed'],
+};
+
+// Every GType this namespace can INSTANTIATE -> the declarations its members come from.
+//
+// The key set is what a UI description file can name: a registered, non-abstract class.
+// Not "every widget" — GtkBuilder resolves a name through `g_type_from_name`, which knows
+// nothing about widgets, and a `.ui` file is full of `GtkSizeGroup`, `GtkTextTag`,
+// `GtkEventController*` and `GtkCellRenderer*`. Use `Widgets` and `CHILD_HOLDERS`
+// below for the narrower questions; they did not move.
+export const DECLS = {
+    CoglAtlas: ['CoglAtlas', 'GObject'],
+    CoglAtlasTexture: ['CoglAtlasTexture', 'CoglTexture', 'GObject'],
+    CoglAttribute: ['CoglAttribute', 'GObject'],
+    CoglAttributeBuffer: ['CoglAttributeBuffer', 'CoglBuffer', 'GObject'],
+    CoglBitmap: ['CoglBitmap', 'GObject'],
+    CoglContext: ['CoglContext', 'GObject'],
+    CoglDisplay: ['CoglDisplay', 'GObject'],
+    CoglFrameInfo: ['CoglFrameInfo', 'GObject'],
+    CoglIndexBuffer: ['CoglIndexBuffer', 'CoglBuffer', 'GObject'],
+    CoglIndices: ['CoglIndices', 'GObject'],
+    CoglMatrixStack: ['CoglMatrixStack', 'GObject'],
+    CoglOffscreen: ['CoglOffscreen', 'CoglFramebuffer', 'GObject'],
+    CoglOnscreen: ['CoglOnscreen', 'CoglFramebuffer', 'GObject'],
+    CoglPipeline: ['CoglPipeline', 'GObject'],
+    CoglPixelBuffer: ['CoglPixelBuffer', 'CoglBuffer', 'GObject'],
+    CoglPrimitive: ['CoglPrimitive', 'GObject'],
+    CoglProgram: ['CoglProgram', 'GObject'],
+    CoglRenderer: ['CoglRenderer', 'GObject'],
+    CoglScanout: ['CoglScanout', 'GObject'],
+    CoglShader: ['CoglShader', 'GObject'],
+    CoglSnippet: ['CoglSnippet', 'GObject'],
+    CoglSubTexture: ['CoglSubTexture', 'CoglTexture', 'GObject'],
+    CoglTexture2D: ['CoglTexture2D', 'CoglTexture', 'GObject'],
+    CoglTexture2DSliced: ['CoglTexture2DSliced', 'CoglTexture', 'GObject'],
+};
+
+// The GTypes above that ARE widgets are the `Widgets` map in the sibling `.d.ts`; these
+// are the ones that merely HOLD one, through `set_child`/`get_child`, descending from
+// `GObject.Object`. A renderer places them like a container; a check asking "is this a
+// widget" must not count them. Derived from the accessor pair, never from a list — the
+// count is in the provenance line above.
+export const CHILD_HOLDERS = [];
+
+export const ENUM_NICKS = {
+    CoglAttributeType: ['byte', 'unsigned-byte', 'short', 'unsigned-short', 'float'],
+    CoglBufferBindTarget: ['pixel-pack', 'pixel-unpack', 'attribute-buffer', 'index-buffer', 'count'],
+    CoglBufferUpdateHint: ['static', 'dynamic', 'stream'],
+    CoglDepthTestFunction: ['never', 'less', 'equal', 'lequal', 'greater', 'notequal', 'gequal', 'always'],
+    CoglFilterReturn: ['continue', 'remove'],
+    CoglIndicesType: ['byte', 'short', 'int'],
+    CoglPixelFormat: ['any', 'a-8', 'rgb-565', 'rgba-4444', 'rgba-5551', 'yuv', 'r-8', 'rg-88', 'rgb-888', 'bgr-888', 'rgbx-8888', 'rgba-8888', 'bgrx-8888', 'bgra-8888', 'xrgb-8888', 'argb-8888', 'xbgr-8888', 'abgr-8888', 'rgba-8888-pre', 'bgra-8888-pre', 'argb-8888-pre', 'abgr-8888-pre', 'rgba-4444-pre', 'rgba-5551-pre', 'rgba-1010102', 'bgra-1010102', 'xrgb-2101010', 'argb-2101010', 'xbgr-2101010', 'abgr-2101010', 'rgba-1010102-pre', 'bgra-1010102-pre', 'argb-2101010-pre', 'abgr-2101010-pre', 'rgbx-fp-16161616', 'rgba-fp-16161616', 'bgrx-fp-16161616', 'bgra-fp-16161616', 'xrgb-fp-16161616', 'argb-fp-16161616', 'xbgr-fp-16161616', 'abgr-fp-16161616', 'rgba-fp-16161616-pre', 'bgra-fp-16161616-pre', 'argb-fp-16161616-pre', 'abgr-fp-16161616-pre', 'rgba-fp-32323232', 'rgba-fp-32323232-pre', 'r-16', 'rg-1616', 'rgba-16161616', 'rgba-16161616-pre', 'depth-16', 'depth-24-stencil-8'],
+    CoglRendererError: ['xlib-display-open', 'bad-constraint'],
+    CoglShaderType: ['vertex', 'fragment'],
+    CoglSystemError: ['cogl-system-error-unsupported', 'cogl-system-error-no-memory'],
+    CoglVerticesMode: ['points', 'lines', 'line-loop', 'line-strip', 'triangles', 'triangle-strip', 'triangle-fan'],
+    CoglWinding: ['clockwise', 'counter-clockwise'],
+    CoglWinsysFeature: ['vblank-counter', 'vblank-wait', 'texture-from-pixmap', 'swap-buffers-event', 'swap-region', 'swap-region-throttle', 'swap-region-synchronized', 'buffer-age', 'sync-and-complete-event', 'n-features'],
+};
+
+// The number behind each of those nicks, read from GIR's own `value` attribute.
+//
+// It ships because position in `ENUM_NICKS` is not the value and a consumer with no
+// typelib has no other way to learn it: a surface without GI still has to hand GObject an
+// integer. The alternative a consumer reaches for first is counting, and counting is wrong
+// on 6 of the 137 enums a GTK 4 vocabulary carries (112 in Gtk-4.0, 25 in Adw-1) --
+// `GtkResponseType` runs -1 down to
+// -11, `GtkTextWindowType` starts at 1, and `GtkConstraintStrength.required` is
+// 1001001000 where counting answers 0.
+//
+// Same provenance as the nicks above, which is the point: a consumer that reads the numbers
+// from an INSTALLED library instead gets two provenances for one table, and a member the
+// vocabulary describes but the host predates then looks like a missing number rather than a
+// version gap.
+export const ENUM_VALUES = {
+    'CoglAttributeType.byte': 5120,
+    'CoglAttributeType.float': 5126,
+    'CoglAttributeType.short': 5122,
+    'CoglAttributeType.unsigned-byte': 5121,
+    'CoglAttributeType.unsigned-short': 5123,
+    'CoglBufferBindTarget.attribute-buffer': 2,
+    'CoglBufferBindTarget.count': 4,
+    'CoglBufferBindTarget.index-buffer': 3,
+    'CoglBufferBindTarget.pixel-pack': 0,
+    'CoglBufferBindTarget.pixel-unpack': 1,
+    'CoglBufferUpdateHint.dynamic': 1,
+    'CoglBufferUpdateHint.static': 0,
+    'CoglBufferUpdateHint.stream': 2,
+    'CoglDepthTestFunction.always': 519,
+    'CoglDepthTestFunction.equal': 514,
+    'CoglDepthTestFunction.gequal': 518,
+    'CoglDepthTestFunction.greater': 516,
+    'CoglDepthTestFunction.lequal': 515,
+    'CoglDepthTestFunction.less': 513,
+    'CoglDepthTestFunction.never': 512,
+    'CoglDepthTestFunction.notequal': 517,
+    'CoglFilterReturn.continue': 0,
+    'CoglFilterReturn.remove': 1,
+    'CoglIndicesType.byte': 0,
+    'CoglIndicesType.int': 2,
+    'CoglIndicesType.short': 1,
+    'CoglPixelFormat.a-8': 17,
+    'CoglPixelFormat.abgr-2101010': 125,
+    'CoglPixelFormat.abgr-2101010-pre': 253,
+    'CoglPixelFormat.abgr-8888': 115,
+    'CoglPixelFormat.abgr-8888-pre': 243,
+    'CoglPixelFormat.abgr-fp-16161616': 123,
+    'CoglPixelFormat.abgr-fp-16161616-pre': 251,
+    'CoglPixelFormat.any': 0,
+    'CoglPixelFormat.argb-2101010': 93,
+    'CoglPixelFormat.argb-2101010-pre': 221,
+    'CoglPixelFormat.argb-8888': 83,
+    'CoglPixelFormat.argb-8888-pre': 211,
+    'CoglPixelFormat.argb-fp-16161616': 91,
+    'CoglPixelFormat.argb-fp-16161616-pre': 219,
+    'CoglPixelFormat.bgr-888': 34,
+    'CoglPixelFormat.bgra-1010102': 61,
+    'CoglPixelFormat.bgra-1010102-pre': 189,
+    'CoglPixelFormat.bgra-8888': 51,
+    'CoglPixelFormat.bgra-8888-pre': 179,
+    'CoglPixelFormat.bgra-fp-16161616': 59,
+    'CoglPixelFormat.bgra-fp-16161616-pre': 187,
+    'CoglPixelFormat.bgrx-8888': 35,
+    'CoglPixelFormat.bgrx-fp-16161616': 43,
+    'CoglPixelFormat.depth-16': 265,
+    'CoglPixelFormat.depth-24-stencil-8': 771,
+    'CoglPixelFormat.r-16': 14,
+    'CoglPixelFormat.r-8': 8,
+    'CoglPixelFormat.rg-1616': 15,
+    'CoglPixelFormat.rg-88': 9,
+    'CoglPixelFormat.rgb-565': 4,
+    'CoglPixelFormat.rgb-888': 2,
+    'CoglPixelFormat.rgba-1010102': 29,
+    'CoglPixelFormat.rgba-1010102-pre': 157,
+    'CoglPixelFormat.rgba-16161616': 26,
+    'CoglPixelFormat.rgba-16161616-pre': 154,
+    'CoglPixelFormat.rgba-4444': 21,
+    'CoglPixelFormat.rgba-4444-pre': 149,
+    'CoglPixelFormat.rgba-5551': 22,
+    'CoglPixelFormat.rgba-5551-pre': 150,
+    'CoglPixelFormat.rgba-8888': 19,
+    'CoglPixelFormat.rgba-8888-pre': 147,
+    'CoglPixelFormat.rgba-fp-16161616': 27,
+    'CoglPixelFormat.rgba-fp-16161616-pre': 155,
+    'CoglPixelFormat.rgba-fp-32323232': 28,
+    'CoglPixelFormat.rgba-fp-32323232-pre': 156,
+    'CoglPixelFormat.rgbx-8888': 3,
+    'CoglPixelFormat.rgbx-fp-16161616': 11,
+    'CoglPixelFormat.xbgr-2101010': 109,
+    'CoglPixelFormat.xbgr-8888': 99,
+    'CoglPixelFormat.xbgr-fp-16161616': 107,
+    'CoglPixelFormat.xrgb-2101010': 77,
+    'CoglPixelFormat.xrgb-8888': 67,
+    'CoglPixelFormat.xrgb-fp-16161616': 75,
+    'CoglPixelFormat.yuv': 7,
+    'CoglRendererError.bad-constraint': 1,
+    'CoglRendererError.xlib-display-open': 0,
+    'CoglShaderType.fragment': 1,
+    'CoglShaderType.vertex': 0,
+    'CoglSystemError.cogl-system-error-no-memory': 1,
+    'CoglSystemError.cogl-system-error-unsupported': 0,
+    'CoglVerticesMode.line-loop': 2,
+    'CoglVerticesMode.line-strip': 3,
+    'CoglVerticesMode.lines': 1,
+    'CoglVerticesMode.points': 0,
+    'CoglVerticesMode.triangle-fan': 6,
+    'CoglVerticesMode.triangle-strip': 5,
+    'CoglVerticesMode.triangles': 4,
+    'CoglWinding.clockwise': 0,
+    'CoglWinding.counter-clockwise': 1,
+    'CoglWinsysFeature.buffer-age': 7,
+    'CoglWinsysFeature.n-features': 9,
+    'CoglWinsysFeature.swap-buffers-event': 3,
+    'CoglWinsysFeature.swap-region': 4,
+    'CoglWinsysFeature.swap-region-synchronized': 6,
+    'CoglWinsysFeature.swap-region-throttle': 5,
+    'CoglWinsysFeature.sync-and-complete-event': 8,
+    'CoglWinsysFeature.texture-from-pixmap': 2,
+    'CoglWinsysFeature.vblank-counter': 0,
+    'CoglWinsysFeature.vblank-wait': 1,
+};
+
+// The nicks GIR marks `deprecated="1"`.
+//
+// Two members of one enum may share a value -- that is how GObject spells an alias, and
+// `GTK_ALIGN_BASELINE` and `GTK_ALIGN_BASELINE_FILL` are both 4. `ENUM_VALUES` keeps
+// both names, so nothing is lost, and this is what says which of the two a number should be
+// spelled back as. Stated rather than derived: the pairing is visible in the values, the
+// DIRECTION is not.
+//
+// Read it as evidence, not as a negative: 4 registered-enum members in the 718 GIRs carry
+// the attribute at all, and 179 of the 182 value-sharing pairs carry it on neither half.
+// A nick missing from here is a nick GIR says nothing about, not a nick GIR calls current.
+export const ENUM_DEPRECATED = [];
+
+// The declared remainder: nicks whose GIR `value` is not a number this can carry.
+//
+// Every nick in `ENUM_NICKS` is in `ENUM_VALUES` or here -- a nick in neither would be a
+// silent drop. GIR carries two shapes no integer holds: a symbolic or absent value (Vala
+// writes `(null)`, a char enum writes a letter) and an integer past
+// `Number.MAX_SAFE_INTEGER`. The value kept here is the raw attribute, so the entry says
+// WHAT was unreadable rather than only that something was. Measured over the 718 GIRs in
+// ts-for-gir's `girs/`: 32 of 34096 registered-enum members, none in Gtk, Adw, GLib or Gio.
+export const ENUM_VALUES_UNREADABLE = {};
+
+// The number behind each member of a registered BITFIELD, keyed the same way.
+//
+// `ENUM_NICKS` refuses a bitfield because GObject cannot resolve a nick SET, and that
+// reason says nothing about one member's number. 23 settable properties in Gtk-4.0 and
+// Adw-1 are bitfield-typed -- `GtkEntry:input-hints`, `GtkPopoverMenu:flags`,
+// `AdwTabView:shortcuts`, `GtkDropTarget:actions`, ... -- and they are typed bare
+// `number`, so a host without GI has nothing to compute one from. Counting is worst
+// exactly here: 119 of the 156 Gtk-4.0 bitfield members this vocabulary carries disagree
+// with their declaration position, against 29 of 672 enumeration members.
+//
+// A table of its own rather than more rows in `ENUM_VALUES`, so that "every nick in
+// `ENUM_NICKS` has a number or a declared reason" stays a claim about one set.
+export const FLAG_VALUES = {
+    'CoglBufferAccess.read': 1,
+    'CoglBufferAccess.read-write': 3,
+    'CoglBufferAccess.write': 2,
+    'CoglBufferBit.color': 1,
+    'CoglBufferBit.depth': 2,
+    'CoglBufferBit.stencil': 4,
+    'CoglBufferMapHint.discard': 1,
+    'CoglBufferMapHint.discard-range': 2,
+    'CoglReadPixelsFlags.color-buffer': 1,
+};
+
+// The same declared remainder for the bitfields. Every one of the 13 members in ts-for-gir's
+// `girs/` whose value is past `Number.MAX_SAFE_INTEGER` is a bitfield member (Fwupd, Qmi),
+// so this is the table that shape actually reaches.
+export const FLAG_VALUES_UNREADABLE = {};
+
+// Declaration GType + property name -> the GType of that property's enum or bitfield.
+//
+// Without it the value tables above are half an answer. A host with no GI knows it must set
+// `orientation` to the number behind the nick `vertical`; `ENUM_VALUES` is keyed
+// `GtkOrientation.vertical`, and nothing else says that `orientation` is a
+// `GtkOrientation`. Deriving it is not available: `never` is a member of several Gtk enums,
+// and choosing between them produces a wrong number rather than a missing one.
+//
+// Only where the property's OWN type is the enum. An array of them and a union that mentions
+// one are both entries a consumer would resolve wrongly, so neither is written.
+//
+// A GType named here has numbers in SOME vocabulary, not necessarily this one: the namespace
+// that OWNS an enum publishes it, so 83 of the 909 entries a full run emits want the owner's
+// vocabulary loaded too. Owners that emit none (Gdk, Pango) are inlined into the tables above.
+export const PROP_ENUMS = {
+    'CoglBuffer.default-target': 'CoglBufferBindTarget',
+    'CoglBuffer.update-hint': 'CoglBufferUpdateHint',
+    'CoglTexture.format': 'CoglPixelFormat',
+};
+
+// `<enum GType>.<nick>` -> the kind of value that ARIA slot takes.
+//
+// The one table here that is not about a ParamSpec. A GtkBuilder or Blueprint
+// `accessibility { … }` block is typed by GTK's ARIA table instead, and the two disagree
+// where it matters: `orientation` is settable on a `GtkLabel` that implements no
+// `GtkOrientable` and has no such property, and `checked` is a `GtkAccessibleTristate`, so
+// `checked: true` means the number 1 and not the boolean. A consumer typing those slots
+// from the widget gets both wrong, silently.
+//
+// Read from each member's own documentation, which is where GTK keeps the table --
+// `gtk_accessible_property_init_value()` is the C half and is not introspectable, the
+// sentence is. Complete or absent, never partial: a member whose documentation states no
+// value type fails generation and names itself, because a missing row is indistinguishable
+// from "GTK has no such name" and the plausible fallback emits `true` where GTK means 1.
+export const ARIA_VALUE_TYPES = {};
+
+// The same keys, for the `'enum'` rows only -> the GType of the enum.
+//
+// The join on from a kind to a number, and a table of its own for the reason `PROP_ENUMS`
+// is one: folding the GType into `ARIA_VALUE_TYPES` would make its values a mix of six
+// reserved words and arbitrary GTypes, and telling them apart would be the consumer's
+// problem. With this, `ARIA_VALUE_TYPES[k] === 'enum'` is the whole test, and
+// `ENUM_NICKS[ARIA_VALUE_ENUMS[k]]` is the nick list.
+export const ARIA_VALUE_ENUMS = {};
+
+export const SLOT_CANDIDATES = {};
+
+export const SINCE = {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@girs/cogl-16",
-    "version": "5.1.0",
+    "version": "5.3.0",
     "description": "GJS TypeScript type definitions for Cogl-16",
     "type": "module",
     "module": "cogl-16.js",
@@ -16,6 +16,11 @@
         "import": "./cogl-16-import.js",
         "default": "./cogl-16-import.js"
       },
+      "./vocabulary": {
+        "types": "./cogl-16-vocabulary.d.ts",
+        "import": "./cogl-16-vocabulary.js",
+        "default": "./cogl-16-vocabulary.js"
+      },
       "./cogl-16": {
         "types": "./cogl-16.d.ts",
         "import": "./cogl-16.js",
@@ -31,13 +36,13 @@
       "test": "tsc --project tsconfig.json"
     },
     "dependencies": {
-      "@girs/gjs": "^5.1.0",
-      "@girs/xlib-2.0": "^5.1.0",
-      "@girs/mtk-16": "^5.1.0",
-      "@girs/graphene-1.0": "^5.1.0",
-      "@girs/gobject-2.0": "^5.1.0",
-      "@girs/glib-2.0": "^5.1.0",
-      "@girs/gl-1.0": "^5.1.0"    },
+      "@girs/gjs": "^5.3.0",
+      "@girs/xlib-2.0": "^5.3.0",
+      "@girs/mtk-16": "^5.3.0",
+      "@girs/graphene-1.0": "^5.3.0",
+      "@girs/gobject-2.0": "^5.3.0",
+      "@girs/glib-2.0": "^5.3.0",
+      "@girs/gl-1.0": "^5.3.0"    },
     "devDependencies": {
       "typescript": "*"
     },

package/tsconfig.json

@@ -41,7 +41,7 @@
       ]
 }
   },
-  "include": ["./cogl-16.d.ts"]
+  "include": ["./cogl-16.d.ts","./cogl-16-vocabulary.d.ts"]
 }