@girs/cvc-1.0 5.1.0 → 5.3.0

package/README.md

@@ -4,7 +4,7 @@
 ![version](https://img.shields.io/npm/v/@girs/cvc-1.0)
 ![downloads/week](https://img.shields.io/npm/dw/@girs/cvc-1.0)
 
-GJS TypeScript type definitions for Cvc-1.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v5.1.0.
+GJS TypeScript type definitions for Cvc-1.0 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/cvc-1.0/ambient` | only the `gi://` module declarations |
 | `@girs/cvc-1.0/import` | only the `imports.gi` declarations |
 | `@girs/cvc-1.0/cvc-1.0` | the namespace, without the side-effecting declarations |
+| `@girs/cvc-1.0/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/cvc-1.0/import`:
 const Cvc = imports.gi.Cvc;
 ```
 
+## Widget vocabulary
+
+`cvc-1.0` 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/cvc-1.0/vocabulary';
+import { OWN_PROPS, ENUM_NICKS, PROVENANCE } from '@girs/cvc-1.0/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/cvc-1.0-vocabulary.d.ts

@@ -0,0 +1,445 @@
+/**
+ * The GIR-derived widget VOCABULARY for Cvc-1.0.
+ *
+ * GENERATED — do not edit. Provenance: Cvc-1.0 — prop(s) no TypeScript value satisfies: Cvc.MixerCard.pa-context Cvc.MixerStream.pa-context Cvc.MixerUIDevice.card
+ *
+ * 9 instantiable GTypes (of which 0 concrete widgets), 10 declarations, 3 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 Cvc from './cvc-1.0.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 GvcMixerControlStateNick = 'closed' | 'ready' | 'connecting' | 'failed';
+export type GvcMixerStreamStateNick = 'invalid' | 'running' | 'idle' | 'suspended';
+export type GvcMixerUIDeviceDirectionNick = 'input' | 'output';
+
+// ---------------------------------------------------------------------------
+// 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 GvcChannelMapProps extends GObjectProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type GvcChannelMapConstructOnly = GObjectConstructOnly;
+
+export interface GvcMixerCardProps extends GObjectProps {
+    /** @default NULL */
+    'icon-name'?: string;
+    /** @default 0 */
+    id?: bigint | number;
+    /** @default 0 */
+    index?: bigint | number;
+    /** @default NULL */
+    name?: string;
+    'pa-context'?: never;
+    /** @default NULL */
+    profile?: string;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type GvcMixerCardConstructOnly = GObjectConstructOnly | 'id' | 'index' | 'pa-context';
+
+export interface GvcMixerControlProps extends GObjectProps {
+    /** @default NULL */
+    name?: string;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type GvcMixerControlConstructOnly = GObjectConstructOnly | 'name';
+
+export interface GvcMixerEventRoleProps extends GvcMixerStreamProps {
+    /** @default NULL */
+    device?: string;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type GvcMixerEventRoleConstructOnly = GvcMixerStreamConstructOnly;
+
+export interface GvcMixerSinkProps extends GvcMixerStreamProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type GvcMixerSinkConstructOnly = GvcMixerStreamConstructOnly;
+
+export interface GvcMixerSinkInputProps extends GvcMixerStreamProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type GvcMixerSinkInputConstructOnly = GvcMixerStreamConstructOnly;
+
+export interface GvcMixerSourceProps extends GvcMixerStreamProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type GvcMixerSourceConstructOnly = GvcMixerStreamConstructOnly;
+
+export interface GvcMixerSourceOutputProps extends GvcMixerStreamProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type GvcMixerSourceOutputConstructOnly = GvcMixerStreamConstructOnly;
+
+export interface GvcMixerStreamProps extends GObjectProps {
+    /** @default NULL */
+    'application-id'?: string;
+    /** @default FALSE */
+    'can-decibel'?: boolean;
+    /** @default 4294967295 */
+    'card-index'?: bigint | number;
+    'channel-map'?: Cvc.ChannelMap;
+    /** @default 0.000000 */
+    decibel?: number;
+    /** @default NULL */
+    description?: string;
+    /** @default NULL */
+    'form-factor'?: string;
+    /** @default NULL */
+    'icon-name'?: string;
+    /** @default 0 */
+    id?: bigint | number;
+    /** @default 0 */
+    index?: bigint | number;
+    /** @default FALSE */
+    'is-event-stream'?: boolean;
+    /** @default FALSE */
+    'is-muted'?: boolean;
+    /** @default FALSE */
+    'is-virtual'?: boolean;
+    /** @default NULL */
+    name?: string;
+    'pa-context'?: never;
+    /** @default NULL */
+    port?: string;
+    /** @default GVC_STREAM_STATE_INVALID */
+    state?: GvcMixerStreamStateNick | Cvc.MixerStreamState;
+    /** @default NULL */
+    'sysfs-path'?: string;
+    /** @default 0 */
+    volume?: bigint | number;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type GvcMixerStreamConstructOnly = GObjectConstructOnly | 'id' | 'index' | 'pa-context';
+
+export interface GvcMixerUIDeviceProps extends GObjectProps {
+    card?: never;
+    /** @default no-name-set */
+    description?: string;
+    /** @default NULL */
+    'icon-name'?: string;
+    /** @default no-name-set */
+    origin?: string;
+    /** @default FALSE */
+    'port-available'?: boolean;
+    /** @default NULL */
+    'port-name'?: string;
+    /** @default 0 */
+    'stream-id'?: number;
+    /** @default 0 */
+    type?: number;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type GvcMixerUIDeviceConstructOnly = GObjectConstructOnly;
+
+// ---------------------------------------------------------------------------
+// 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/cvc-1.0-vocabulary.js

@@ -0,0 +1,187 @@
+// The widget vocabulary of Cvc-1.0 as runtime data.
+//
+// GENERATED — do not edit. Provenance: Cvc-1.0 — prop(s) no TypeScript value satisfies: Cvc.MixerCard.pa-context Cvc.MixerStream.pa-context Cvc.MixerUIDevice.card
+//
+// 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: 'Cvc',
+    version: '1.0',
+    libraryVersion: null,
+    childHolders: 0,
+    droppedBases: [],
+    inlinedBases: [],
+    unsettableProps: ['Cvc.MixerCard.pa-context', 'Cvc.MixerStream.pa-context', 'Cvc.MixerUIDevice.card'],
+    unresolvedProps: [],
+    identifierPrefixes: ['Gvc'],
+    requiredVocabularies: ['@girs/gobject-2.0/vocabulary'],
+};
+
+export const OWN_PROPS = {
+    GvcMixerCard: ['icon-name', 'id', 'index', 'name', 'pa-context', 'profile'],
+    GvcMixerControl: ['name'],
+    GvcMixerEventRole: ['device'],
+    GvcMixerStream: ['application-id', 'can-decibel', 'card-index', 'channel-map', 'decibel', 'description', 'form-factor', 'icon-name', 'id', 'index', 'is-event-stream', 'is-muted', 'is-virtual', 'name', 'pa-context', 'port', 'state', 'sysfs-path', 'volume'],
+    GvcMixerUIDevice: ['card', 'description', 'icon-name', 'origin', 'port-available', 'port-name', 'stream-id', 'type'],
+};
+
+export const OWN_SIGNALS = {
+    GvcChannelMap: ['volume-changed'],
+    GvcMixerControl: ['active-input-update', 'active-output-update', 'audio-device-selection-needed', 'card-added', 'card-removed', 'default-sink-changed', 'default-source-changed', 'input-added', 'input-removed', 'output-added', 'output-removed', 'state-changed', 'stream-added', 'stream-changed', 'stream-removed'],
+    GvcMixerStream: ['monitor-suspend', 'monitor-update'],
+};
+
+// 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 = {
+    GvcChannelMap: ['GvcChannelMap', 'GObject'],
+    GvcMixerCard: ['GvcMixerCard', 'GObject'],
+    GvcMixerControl: ['GvcMixerControl', 'GObject'],
+    GvcMixerEventRole: ['GvcMixerEventRole', 'GvcMixerStream', 'GObject'],
+    GvcMixerSink: ['GvcMixerSink', 'GvcMixerStream', 'GObject'],
+    GvcMixerSinkInput: ['GvcMixerSinkInput', 'GvcMixerStream', 'GObject'],
+    GvcMixerSource: ['GvcMixerSource', 'GvcMixerStream', 'GObject'],
+    GvcMixerSourceOutput: ['GvcMixerSourceOutput', 'GvcMixerStream', 'GObject'],
+    GvcMixerUIDevice: ['GvcMixerUIDevice', '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 = {
+    GvcMixerControlState: ['closed', 'ready', 'connecting', 'failed'],
+    GvcMixerStreamState: ['invalid', 'running', 'idle', 'suspended'],
+    GvcMixerUIDeviceDirection: ['input', 'output'],
+};
+
+// 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 = {
+    'GvcMixerControlState.closed': 0,
+    'GvcMixerControlState.connecting': 2,
+    'GvcMixerControlState.failed': 3,
+    'GvcMixerControlState.ready': 1,
+    'GvcMixerStreamState.idle': 2,
+    'GvcMixerStreamState.invalid': 0,
+    'GvcMixerStreamState.running': 1,
+    'GvcMixerStreamState.suspended': 3,
+    'GvcMixerUIDeviceDirection.input': 0,
+    'GvcMixerUIDeviceDirection.output': 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 = {
+    'GvcHeadsetPortChoice.headphones': 1,
+    'GvcHeadsetPortChoice.headset': 2,
+    'GvcHeadsetPortChoice.mic': 4,
+    'GvcHeadsetPortChoice.none': 0,
+};
+
+// 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 = {
+    'GvcMixerStream.state': 'GvcMixerStreamState',
+};
+
+// `<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/cvc-1.0",
-    "version": "5.1.0",
+    "version": "5.3.0",
     "description": "GJS TypeScript type definitions for Cvc-1.0",
     "type": "module",
     "module": "cvc-1.0.js",
@@ -16,6 +16,11 @@
         "import": "./cvc-1.0-import.js",
         "default": "./cvc-1.0-import.js"
       },
+      "./vocabulary": {
+        "types": "./cvc-1.0-vocabulary.d.ts",
+        "import": "./cvc-1.0-vocabulary.js",
+        "default": "./cvc-1.0-vocabulary.js"
+      },
       "./cvc-1.0": {
         "types": "./cvc-1.0.d.ts",
         "import": "./cvc-1.0.js",
@@ -31,11 +36,11 @@
       "test": "tsc --project tsconfig.json"
     },
     "dependencies": {
-      "@girs/gjs": "^5.1.0",
-      "@girs/gio-2.0": "^5.1.0",
-      "@girs/gobject-2.0": "^5.1.0",
-      "@girs/glib-2.0": "^5.1.0",
-      "@girs/gmodule-2.0": "^5.1.0"    },
+      "@girs/gjs": "^5.3.0",
+      "@girs/gio-2.0": "^5.3.0",
+      "@girs/gobject-2.0": "^5.3.0",
+      "@girs/glib-2.0": "^5.3.0",
+      "@girs/gmodule-2.0": "^5.3.0"    },
     "devDependencies": {
       "typescript": "*"
     },

package/tsconfig.json

@@ -35,7 +35,7 @@
       ]
 }
   },
-  "include": ["./cvc-1.0.d.ts"]
+  "include": ["./cvc-1.0.d.ts","./cvc-1.0-vocabulary.d.ts"]
 }