@gjsify/react-native 0.43.0

package/lib/types/app-registry.d.ts

@@ -0,0 +1,50 @@
+import { type ComponentType } from 'react';
+/** What `registerComponent` is handed: a function returning the root component. */
+export type ComponentProvider = () => ComponentType<Record<string, unknown>>;
+/** The gjsify-shaped half of `runApplication`'s parameters. */
+export interface RunApplicationOptions {
+    /**
+     * GApplication id. REQUIRED, and the declared divergence from React Native:
+     * a phone host supplies the application identity, a desktop one is the
+     * application.
+     */
+    applicationId: string;
+    /** Window title. Defaults to the registered app key. */
+    title?: string;
+    /** Initial window size. Defaults to 900x700, which is an ordinary desktop default. */
+    defaultWidth?: number;
+    defaultHeight?: number;
+    /** Props handed to the root component — React Native's `initialProps`. */
+    initialProps?: Record<string, unknown>;
+    /** CSS applied display-wide on startup. The class compiler's output goes here. */
+    css?: string;
+}
+interface Registration {
+    readonly provider: ComponentProvider;
+}
+export declare const AppRegistry: {
+    /** Register a root component under `appKey`. React Native's own signature. */
+    readonly registerComponent: (appKey: string, componentProvider: ComponentProvider) => string;
+    /** Every registered key, in registration order. React Native's own signature. */
+    readonly getAppKeys: () => string[];
+    /** Whether `appKey` was registered. */
+    readonly getRunnable: (appKey: string) => Registration | undefined;
+    /**
+     * Create the application, mount the registered component, and run the loop.
+     *
+     * Resolves with the application's exit code, so a caller can `await` it and
+     * still `return process.exit(code)` — a bare `process.exit()` in a GJS app is
+     * the core-dump shape recorded in the CLI's own notes.
+     */
+    readonly runApplication: (appKey: string, options: RunApplicationOptions) => Promise<number>;
+    /** React Native's teardown hook. Unmounts the tree; the loop is the caller's. */
+    readonly unmountApplicationComponentAtRootTag: () => void;
+};
+/**
+ * Expo's spelling: register under `"main"` and run.
+ *
+ * The one line an Expo entry file contains, so an application's `index.js` needs no
+ * `.gtk` variant just to start.
+ */
+export declare function registerRootComponent(component: ComponentType<Record<string, unknown>>, options: RunApplicationOptions): Promise<number>;
+export {};

package/lib/types/components.d.ts

@@ -0,0 +1,77 @@
+import { type ReactElement, type ReactNode, type Ref } from 'react';
+import type { ClassNameInput } from './primitives/classes.js';
+import type { StyleInput } from './primitives/style.js';
+/** What every primitive accepts on top of its own props. */
+export interface CommonProps {
+    className?: ClassNameInput;
+    style?: StyleInput;
+    children?: ReactNode;
+    /** The `Gtk.Widget` itself — the host's `getPublicInstance` hands back the real widget. */
+    ref?: Ref<unknown>;
+    testID?: string;
+}
+export interface ViewProps extends CommonProps {
+    /** `auto` and `none` only — GTK's `can-target` covers the widget AND its subtree. */
+    pointerEvents?: 'auto' | 'none';
+}
+export declare function View(props: ViewProps): ReactElement;
+export interface TextProps extends CommonProps {
+    numberOfLines?: number;
+    ellipsizeMode?: 'head' | 'middle' | 'tail';
+    selectable?: boolean;
+}
+export declare function Text(props: TextProps): ReactElement;
+export interface PressableProps extends CommonProps {
+    onPress?: () => void;
+    disabled?: boolean;
+    pointerEvents?: 'auto' | 'none';
+    /**
+     * `ReactNode`, NEVER a function.
+     *
+     * ADR 0032 § 7: children-as-a-function-of-`{ pressed }` belongs to the "usable"
+     * milestone and is a NAMED BUILD-TIME REFUSAL until then. This declaration is
+     * that build-time half — `children={({ pressed }) => …}` becomes a type error
+     * naming the property — and it earns its place on its own: the press state is
+     * the GTK CSS `:active` pseudo-class, so `active:opacity-70` already does what
+     * nearly every use of the function form does, with no re-render at all. Measured
+     * in the application ADR 0032 read: ZERO occurrences of the function form.
+     */
+    children?: ReactNode;
+}
+export declare function Pressable(props: PressableProps): ReactElement;
+export interface ScrollViewProps extends CommonProps {
+    horizontal?: boolean;
+    showsVerticalScrollIndicator?: boolean;
+    showsHorizontalScrollIndicator?: boolean;
+    contentContainerStyle?: StyleInput;
+    /** NativeWind's spelling for the inner node's class list. See `ContentSpec.classNameProp`. */
+    contentContainerClassName?: ClassNameInput;
+}
+export declare function ScrollView(props: ScrollViewProps): ReactElement;
+export interface ActivityIndicatorProps extends CommonProps {
+    animating?: boolean;
+    size?: 'small' | 'large' | number;
+    color?: string;
+    hidesWhenStopped?: boolean;
+}
+export declare function ActivityIndicator(props: ActivityIndicatorProps): ReactElement;
+export interface TextInputProps extends CommonProps {
+    value?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    onChangeText?: (text: string) => void;
+    onSubmitEditing?: () => void;
+    /** One prop, two widgets: `Gtk.Entry` without it, `Gtk.TextView` with it. */
+    multiline?: boolean;
+    editable?: boolean;
+    maxLength?: number;
+    secureTextEntry?: boolean;
+    keyboardType?: 'default' | 'email-address' | 'phone-pad' | 'number-pad' | 'numeric' | 'decimal-pad' | 'url';
+}
+export declare function TextInput(props: TextInputProps): ReactElement;
+export interface SwitchProps extends CommonProps {
+    value?: boolean;
+    onValueChange?: (value: boolean) => void;
+    disabled?: boolean;
+}
+export declare function Switch(props: SwitchProps): ReactElement;

package/lib/types/event-emitter.d.ts

@@ -0,0 +1,29 @@
+/** What `addListener` hands back. Removal is by object, never by function identity. */
+export interface EventSubscription {
+    remove(): void;
+}
+export declare class EventEmitter<TEvents extends Record<string, readonly unknown[]> = Record<string, readonly unknown[]>> {
+    #private;
+    /**
+     * Call `listener` on every `emit` of `eventType`, until the subscription is removed.
+     *
+     * `context` is React Native's own third parameter: the `this` the listener is
+     * called with. Kept because code in the wild passes it, even though a bound
+     * function or an arrow is the better spelling.
+     */
+    addListener<K extends keyof TEvents & string>(eventType: K, listener: (...args: TEvents[K]) => void, context?: unknown): EventSubscription;
+    /**
+     * Call every current listener of `eventType`.
+     *
+     * The list is COPIED before iterating. Without that, a listener that removes
+     * itself shifts the array under the loop and the next listener is skipped — a
+     * self-unsubscribing listener is the common case, so this is not a corner. The
+     * `removed` flag then covers the other half: a listener removed by an EARLIER
+     * listener in the same emit must not be called from the copy.
+     */
+    emit<K extends keyof TEvents & string>(eventType: K, ...args: TEvents[K]): void;
+    /** Drop every listener of `eventType`, or every listener of every type. */
+    removeAllListeners<K extends keyof TEvents & string>(eventType?: K): void;
+    /** How many listeners `eventType` currently has. */
+    listenerCount<K extends keyof TEvents & string>(eventType: K): number;
+}

package/lib/types/event-emitter.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/generated/unsupported-exports.d.ts

@@ -0,0 +1,78 @@
+export declare const Modal: never;
+export declare const StyleSheet: never;
+export declare const FlatList: never;
+export declare const SectionList: never;
+export declare const VirtualizedList: never;
+export declare const VirtualizedSectionList: never;
+export declare const Image: never;
+export declare const ImageBackground: never;
+export declare const TouchableOpacity: never;
+export declare const TouchableHighlight: never;
+export declare const TouchableWithoutFeedback: never;
+export declare const Button: never;
+export declare const Dimensions: never;
+export declare const useWindowDimensions: never;
+export declare const Alert: never;
+export declare const Appearance: never;
+export declare const SafeAreaView: never;
+export declare const StatusBar: never;
+export declare const KeyboardAvoidingView: never;
+export declare const Keyboard: never;
+export declare const RefreshControl: never;
+export declare const AppState: never;
+export declare const PixelRatio: never;
+export declare const PlatformColor: never;
+export declare const AccessibilityInfo: never;
+export declare const Animated: never;
+export declare const Easing: never;
+export declare const LayoutAnimation: never;
+export declare const InteractionManager: never;
+export declare const useAnimatedValue: never;
+export declare const useAnimatedValueXY: never;
+export declare const useAnimatedColor: never;
+export declare const PanResponder: never;
+export declare const usePressability: never;
+export declare const DrawerLayoutAndroid: never;
+export declare const I18nManager: never;
+export declare const LogBox: never;
+export declare const Systrace: never;
+export declare const Vibration: never;
+export declare const ToastAndroid: never;
+export declare const InputAccessoryView: never;
+export declare const TouchableNativeFeedback: never;
+export declare const ActionSheetIOS: never;
+export declare const PushNotificationIOS: never;
+export declare const PermissionsAndroid: never;
+export declare const Settings: never;
+export declare const Clipboard: never;
+export declare const BackHandler: never;
+export declare const DynamicColorIOS: never;
+export declare const processColor: never;
+export declare const UTFSequence: never;
+export declare const experimental_LayoutConformance: never;
+export declare const unstable_VirtualView: never;
+export declare const VirtualViewMode: never;
+export declare const unstable_NativeText: never;
+export declare const unstable_NativeView: never;
+export declare const unstable_TextAncestorContext: never;
+export declare const ReactNativeVersion: never;
+export declare const DeviceInfo: never;
+export declare const DevMenu: never;
+export declare const DevSettings: never;
+export declare const NativeModules: never;
+export declare const TurboModuleRegistry: never;
+export declare const NativeComponentRegistry: never;
+export declare const requireNativeComponent: never;
+export declare const codegenNativeComponent: never;
+export declare const codegenNativeCommands: never;
+export declare const UIManager: never;
+export declare const findNodeHandle: never;
+export declare const registerCallableModule: never;
+export declare const Networking: never;
+export declare const NativeDialogManagerAndroid: never;
+export declare const ProgressBarAndroid: never;
+export declare const Touchable: never;
+export declare const NativeEventEmitter: never;
+export declare const DeviceEventEmitter: never;
+export declare const NativeAppEventEmitter: never;
+export declare const RootTagContext: never;

package/lib/types/hooks.d.ts

@@ -0,0 +1,13 @@
+import { type ColorSchemeName } from './apis/color-scheme.js';
+/**
+ * The desktop's current colour scheme, re-rendering when it changes.
+ *
+ * Reports what the user is LOOKING AT (`Adw.StyleManager:dark`), not what the
+ * application asked for — see `apis/color-scheme.ts` for why those are two
+ * different questions and which one React Native means.
+ *
+ * The server snapshot is the same read: there is no server, and returning a
+ * different value there is what produces a hydration mismatch in the one
+ * environment that has none.
+ */
+export declare function useColorScheme(): ColorSchemeName;

package/lib/types/index.d.ts

@@ -0,0 +1,22 @@
+export { AppRegistry, registerRootComponent } from './app-registry.js';
+export type { ComponentProvider, RunApplicationOptions } from './app-registry.js';
+export { EventEmitter } from './event-emitter.js';
+export type { EventSubscription } from './event-emitter.js';
+export { ActivityIndicator, Pressable, ScrollView, Switch, Text, TextInput, View } from './components.js';
+export type { ActivityIndicatorProps, CommonProps, PressableProps, ScrollViewProps, SwitchProps, TextInputProps, TextProps, ViewProps, } from './components.js';
+export { Linking, Platform, Share } from './apis/index.js';
+export type { ColorSchemeName, PlatformOS, PlatformSelectSpec, ShareAction, ShareContent } from './apis/index.js';
+export { useColorScheme } from './hooks.js';
+export { configureStyle, resetStyleConfig, styleConfig } from './style-config.js';
+export type { StyleConfig } from './style-config.js';
+export * as primitives from './primitives/index.js';
+export { PrimitiveError } from './primitives/errors.js';
+/**
+ * React 19 batches every update on its own, so this is the identity call it already
+ * is upstream — kept because application code and libraries still wrap in it, and an
+ * absent export would refuse something that costs nothing to honour.
+ */
+export declare function unstable_batchedUpdates<T, R>(callback: (argument: T) => R, argument: T): R;
+export * from './generated/unsupported-exports.js';
+export { SUPPORT_TABLE, SUPPORTED_NAMES, explainUnsupported, isImportable, type SupportEntry, type SupportStatus, type SupportTier, } from './support-table.js';
+export { UnsupportedError } from './unsupported.js';

package/lib/types/primitives/classes.d.ts

@@ -0,0 +1,23 @@
+/** A class list split into the base group and one group per variant. */
+export interface ClassGroups {
+    /** Utilities with no variant prefix, in author order — last wins downstream. */
+    readonly base: readonly string[];
+    /** Variant name → its utilities, in author order. */
+    readonly variants: Readonly<Record<string, readonly string[]>>;
+}
+/** What React Native / NativeWind accept as a `className`. */
+export type ClassNameInput = string | readonly (string | false | null | undefined)[] | null | undefined;
+/**
+ * A class list → `{ base, variants }`.
+ *
+ * `primitive` is carried only so a refusal can name the element the author wrote;
+ * nothing about the split depends on it.
+ *
+ * WHITESPACE, NOT A SINGLE SPACE: 24 of the measured application's `className=`
+ * sites are computed rather than literal (ADR 0032 § 3), and a template literal
+ * across lines produces newlines and runs of spaces. Splitting on `' '` left empty
+ * tokens, and an empty token reaching `resolveUtility` is an "unknown utility"
+ * naming the empty string — a diagnostic that describes the splitter rather than
+ * the input.
+ */
+export declare function splitVariants(className: ClassNameInput, primitive: string): ClassGroups;

package/lib/types/primitives/classes.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/primitives/errors.d.ts

@@ -0,0 +1,9 @@
+/** A primitive, prop or combination this layer cannot answer for, and why. */
+export declare class PrimitiveError extends Error {
+    readonly name = "PrimitiveError";
+    /** The primitive the refusal is about — `View`, `Text`, … */
+    readonly primitive: string;
+    /** The prop, utility or combination that caused it. Empty when it is the primitive itself. */
+    readonly subject: string;
+    constructor(primitive: string, subject: string, detail: string);
+}

package/lib/types/primitives/index.d.ts

@@ -0,0 +1,11 @@
+export { splitVariants } from './classes.js';
+export type { ClassGroups, ClassNameInput } from './classes.js';
+export { PrimitiveError } from './errors.js';
+export { resolveIntent } from './intents.js';
+export type { ChildContext, ChildFacts, IntentInput, IntentResolution, Orientation, WidgetFacts } from './intents.js';
+export { declaresAbsolute, resolvePrimitive } from './resolve.js';
+export type { PrimitiveContext, PrimitivePlan, PrimitiveProps, ResolvedEvent, WidgetNode } from './resolve.js';
+export { flattenStyle, mintClass, normalise, variantDeclarations } from './style.js';
+export type { ClassNameSink, StyleAuthored, StyleInput, StyleObject } from './style.js';
+export { FRAMEWORK_PROPS, PRIMITIVE_NAMES, PRIMITIVES } from './table.js';
+export type { Coercion, ContentSpec, EventRoute, IgnoredRoute, PrimitiveSpec, PropRoute, PropertyRoute, RefusedRoute, StylePropertyRoute, } from './table.js';

package/lib/types/primitives/intents.d.ts

@@ -0,0 +1,65 @@
+import type { LayoutIntent } from '@gjsify/gtk-host/style';
+export type Orientation = 'horizontal' | 'vertical';
+/**
+ * What a parent tells its children — and what a child reads about its parent.
+ *
+ * ONE record in both directions on purpose: every field is a fact the parent knows
+ * and the child needs, so a second shape for "what I publish" versus "what I read"
+ * would be the same four fields under different names.
+ */
+export interface ChildContext {
+    /** The parent's own orientation. The axis a child's `flex-1` expands along. */
+    readonly orientation: Orientation;
+    /**
+     * Properties every child carries unless it overrides them.
+     *
+     * A resolved `alignItems`. It is a DEFAULT rather than a command, because
+     * `align-self` beats `align-items` in flexbox and a child that set its own
+     * `self-*` must win — which it does, by being merged after this.
+     */
+    readonly props: Readonly<Record<string, unknown>>;
+    /** True when the parent is a `Gtk.Overlay` and can take an absolutely positioned child. */
+    readonly overlay: boolean;
+    /** A `textAlign` still looking for a widget that aligns text. */
+    readonly textAlign?: 'left' | 'center' | 'right' | 'justify';
+}
+/** What the element's own children change about the element. */
+export interface ChildFacts {
+    /** How many children declare `position: absolute` — non-zero makes a `View` an overlay. */
+    readonly absolute: number;
+    /** How many children there are at all. */
+    readonly count: number;
+    /** Whether any child is a text run, which competes with a prop for the text sink. */
+    readonly text: boolean;
+}
+/** What the element's own widget can take. Declared per primitive, measured in the spec. */
+export interface WidgetFacts {
+    /** Installs `orientation` and `spacing` — a `Gtk.Box`. */
+    readonly box: boolean;
+    /** Installs `xalign` and `justify` — a `Gtk.Label`. */
+    readonly alignsText: boolean;
+}
+export interface IntentInput {
+    readonly primitive: string;
+    readonly intent: LayoutIntent;
+    /** The element's own orientation, for the node its children go into. */
+    readonly orientation: Orientation;
+    readonly widget: WidgetFacts;
+    readonly parent?: ChildContext;
+    readonly children?: ChildFacts;
+    /** Widget properties already emitted by L1, read only to catch a clash. */
+    readonly emittedProps: Readonly<Record<string, unknown>>;
+}
+export interface IntentResolution {
+    /** Widget properties this resolution adds, GTK spelling. */
+    readonly props: Readonly<Record<string, unknown>>;
+    /** GTK CSS declarations this resolution adds, before the class is minted. */
+    readonly css: readonly string[];
+    /** What this element publishes to its children. */
+    readonly childContext: ChildContext;
+    /** The `slot` this element declares to its parent, or null. */
+    readonly slot: string | null;
+    /** What is still unresolved, for a caller that knows more. */
+    readonly remaining: LayoutIntent;
+}
+export declare function resolveIntent(input: IntentInput): IntentResolution;

package/lib/types/primitives/primitives.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/primitives/resolve.d.ts

@@ -0,0 +1,71 @@
+import type { LayoutIntent, StyleTokens } from '@gjsify/gtk-host/style';
+import type { ClassNameInput } from './classes.js';
+import { type ChildContext, type ChildFacts, type Orientation, type WidgetFacts } from './intents.js';
+import { type ClassNameSink, type StyleInput } from './style.js';
+/** Everything L2 needs that is not the primitive and not its props. */
+export interface PrimitiveContext {
+    /** The project's own token scales. ADR 0032 § 3: the families are declared, the values are the project's. */
+    readonly tokens: StyleTokens;
+    /** Where a declaration set becomes a class name. `StyleSheet` satisfies this structurally. */
+    readonly sheet: ClassNameSink;
+    /** What the parent published. Absent at a root, and then `expand`/`alignSelf` pass up. */
+    readonly parent?: ChildContext;
+    /** What the element's own children are. Absent means "no children", not "unknown". */
+    readonly children?: ChildFacts;
+}
+/** One GTK node in the plan. */
+export interface WidgetNode {
+    /** GType name — the tag the host takes. */
+    readonly tag: string;
+    /** Widget properties in GTK's own spelling, for the host to coerce and apply. */
+    readonly props: Readonly<Record<string, unknown>>;
+    /** `css-classes`. At most one generated name, plus whatever the primitive always carries. */
+    readonly cssClasses: readonly string[];
+}
+/** A GTK signal this element binds, and how to build the React Native argument. */
+export interface ResolvedEvent {
+    /** The React Native prop that supplied the callback. */
+    readonly prop: string;
+    /** The GObject signal name, in GObject's spelling. */
+    readonly signal: string;
+    /** The widget property to read for the callback's argument, or null for no argument. */
+    readonly read: string | null;
+}
+export interface PrimitivePlan {
+    readonly primitive: string;
+    /** The node the PARENT adopts. */
+    readonly node: WidgetNode;
+    /** The node the element's ordinary children go into, when it is not `node`. */
+    readonly content: WidgetNode | null;
+    /** The `slot` this element declares to its parent, or null. */
+    readonly slot: string | null;
+    /** Where an absolutely positioned CHILD goes: into `node`, under this slot. */
+    readonly absoluteSlot: string | null;
+    readonly events: readonly ResolvedEvent[];
+    /** Where a text child goes, or null when text under this primitive is refused. */
+    readonly textSink: string | null;
+    /** What this element publishes to its children. */
+    readonly childContext: ChildContext;
+    /** What L2 could not answer. Empty when the caller supplied a parent. */
+    readonly intent: LayoutIntent;
+}
+/** What one element authored, in React Native's own spelling. */
+export type PrimitiveProps = Readonly<Record<string, unknown>> & {
+    readonly className?: ClassNameInput;
+    readonly style?: StyleInput;
+};
+/**
+ * Does this style declare `position: absolute`?
+ *
+ * A PARENT needs the answer about its CHILDREN — `absolute` is triggered by the
+ * child, never by the element (ADR 0032 § 3) — and the parent has the children's
+ * props before it has their plans.
+ *
+ * It runs the real resolution rather than testing for the literal string
+ * `absolute`, because the syntactic test is exact only while L1's vocabulary has
+ * exactly one spelling for it. It has two today (`absolute`, and `style={{
+ * position: 'absolute' }}`) and nothing stops it having three.
+ */
+export declare function declaresAbsolute(props: PrimitiveProps, tokens: StyleTokens, primitive?: string): boolean;
+export declare function resolvePrimitive(primitive: string, props: PrimitiveProps, context: PrimitiveContext): PrimitivePlan;
+export type { ChildContext, ChildFacts, Orientation, WidgetFacts };

package/lib/types/primitives/style.d.ts

@@ -0,0 +1,73 @@
+import { partition, type Partitioned, type StyleProps } from '@gjsify/gtk-host/style';
+import type { StyleTokens } from '@gjsify/gtk-host/style';
+import { type ClassGroups, type ClassNameInput } from './classes.js';
+/**
+ * A React Native `style` prop.
+ *
+ * Arrays nest, and `false` / `null` / `undefined` are what a short-circuit
+ * (`style={[base, active && overlay]}`) leaves behind — React Native's own
+ * `StyleSheet.flatten` accepts all of it, so the alias has to as well.
+ */
+export type StyleInput = StyleObject | StyleInputArray | false | null | undefined;
+export type StyleObject = Readonly<Record<string, unknown>>;
+interface StyleInputArray extends ReadonlyArray<StyleInput> {
+}
+/**
+ * A `style` prop → one flat object, later entries winning.
+ *
+ * React Native's own rule, and the reason it is spelled out rather than assumed:
+ * `[a, b]` means "b over a", so a `reduce` that merged in the other direction
+ * would make every conditional override a no-op — and a no-op override looks
+ * exactly like a style that was never written.
+ */
+export declare function flattenStyle(style: StyleInput): StyleObject;
+/** What one element authored, before any of it has been interpreted. */
+export interface StyleAuthored {
+    readonly className?: ClassNameInput;
+    readonly style?: StyleInput;
+}
+/**
+ * `{ className, style }` → the property record L1 partitions.
+ *
+ * The class list's VARIANTS do not come through here: they are a different
+ * question (WHEN a declaration applies) with a different destination (a
+ * pseudo-class on the generated selector), so they are returned beside the record
+ * rather than folded into it.
+ */
+export declare function normalise(authored: StyleAuthored, tokens: StyleTokens, primitive: string): {
+    readonly props: StyleProps;
+    readonly groups: ClassGroups;
+};
+/**
+ * A variant group → the CSS declarations its pseudo-class carries.
+ *
+ * A VARIANT CAN ONLY CHANGE CSS, and that is the refusal this function exists for.
+ * `active:opacity-70` is a declaration on `.x:active` and costs nothing at
+ * runtime — GTK animates the state itself (ADR 0032 § 7). `active:flex-1` asks for
+ * the widget property `hexpand` to change while a finger is down, and GTK has no
+ * pseudo-class form of a widget property at all: there is no `:active` variant of
+ * `hexpand`. Letting that through would emit a class whose `:active` rule is empty
+ * and a widget property applied unconditionally — a style that is wrong in both
+ * states and loud in neither.
+ */
+export declare function variantDeclarations(groups: ClassGroups, tokens: StyleTokens, primitive: string): Readonly<Record<string, readonly string[]>>;
+/** The narrow half of `StyleSheet` L2 needs: declarations in, a class name out. */
+export interface ClassNameSink {
+    classFor(declarations: readonly string[], variants?: Readonly<Record<string, readonly string[]>>): string;
+}
+/**
+ * Mint the ONE class name a set of declarations gets, or `null` for "no style".
+ *
+ * A STRUCTURAL interface rather than `StyleSheet` itself, and the reason is the
+ * test rather than the abstraction: `StyleSheet` constructs a `Gtk.CssProvider` and
+ * installs it on a `Gdk.Display`, so a spec that wanted to assert which class a
+ * `<View className="…">` gets would need a display to check a pure-data decision.
+ * `StyleSheet` satisfies this interface without knowing it exists.
+ *
+ * `classFor` REFUSES an empty declaration set by name ("an empty class would name
+ * nothing"), so the empty case is answered here instead of being handed on.
+ */
+export declare function mintClass(sheet: ClassNameSink, declarations: readonly string[], variants: Readonly<Record<string, readonly string[]>>): string | null;
+/** `partition`, re-exported so a caller of L2 needs one import for the style path. */
+export type { Partitioned, StyleProps, StyleTokens };
+export { partition };