akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/types/ui/Dialog/Provider.d.ts

@@ -1,13 +1,46 @@
 import { type ReactNode } from "react";
+export interface DialogContextType {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openDialog: () => void;
+    closeDialog: () => void;
+    /** The drawing surface's own dismissal, where `confirmClose` and `onCancel` live; flipping `open` skips both. */
+    registerDismiss: (dismiss: (() => void) | null) => void;
+    title: ReactNode;
+    setTitle: (title: ReactNode) => void;
+    action: ReactNode;
+    setAction: (action: ReactNode) => void;
+}
+export declare const DialogContext: import("react").Context<DialogContextType>;
 export interface ProviderProps {
-    /** Additional classes for the dialog root wrapper. */
     className?: string;
-    /** Controlled open state. */
     open?: boolean;
-    /** Initial open state for uncontrolled usage. */
     defaultOpen?: boolean;
-    /** Names this dialog for the in-page agent. Without it the dialog publishes nothing — two on one screen would share a name. */
+    /** Names this dialog for the in-page agent; without it the dialog publishes nothing. */
     namespace?: string;
     children?: ReactNode;
 }
 export declare const Provider: ({ className, defaultOpen, open, namespace, children, }: ProviderProps) => import("react/jsx-runtime").JSX.Element;
+export interface TitleProps {
+    children?: ReactNode;
+}
+export declare const Title: ({ children }: TitleProps) => null;
+export interface ActionProps {
+    children?: ReactNode;
+}
+export declare const Action: ({ children }: ActionProps) => null;
+export interface ContentProps {
+    className?: string;
+    children?: ReactNode;
+}
+export declare const Content: ({ className, children }: ContentProps) => import("react/jsx-runtime").JSX.Element;
+export interface TriggerProps {
+    className?: string;
+    children?: ReactNode;
+}
+export declare const Trigger: ({ className, children }: TriggerProps) => import("react/jsx-runtime").JSX.Element;
+export interface CloseProps {
+    className?: string;
+    children?: ReactNode;
+}
+export declare const Close: ({ className, children }: CloseProps) => import("react/jsx-runtime").JSX.Element;

package/types/ui/Dialog/index.d.ts

@@ -3,8 +3,8 @@ export declare const Dialog: {
     ({ children, ...props }: ProviderProps): import("react/jsx-runtime").JSX.Element;
     Modal: ({ className, bodyClassName, confirmClose, closeButton, children, onCancel }: import("./Modal.d.ts").ModalProps) => import("react").ReactPortal | null;
     LegacyModal: ({ className, bodyClassName, confirmClose, children, onCancel }: import("./LegacyModal.d.ts").LegacyModalProps) => import("react").ReactPortal | null;
-    Title: ({ children }: import("./Title.d.ts").TitleProps) => null;
-    Action: ({ children }: import("./Action.d.ts").ActionProps) => null;
-    Trigger: ({ className, children }: import("./Trigger.d.ts").TriggerProps) => import("react/jsx-runtime").JSX.Element;
-    Content: ({ className, children }: import("./Content.d.ts").ContentProps) => import("react/jsx-runtime").JSX.Element;
+    Title: ({ children }: import("./Provider.d.ts").TitleProps) => null;
+    Action: ({ children }: import("./Provider.d.ts").ActionProps) => null;
+    Trigger: ({ className, children }: import("./Provider.d.ts").TriggerProps) => import("react/jsx-runtime").JSX.Element;
+    Content: ({ className, children }: import("./Provider.d.ts").ContentProps) => import("react/jsx-runtime").JSX.Element;
 };

package/types/ui/Dropdown.d.ts

@@ -6,22 +6,14 @@ export interface DropdownProps {
     value?: ReactNode;
     /** Whole trigger element, drawn instead of that button. The menu's click and aria state land on it. */
     trigger?: ReactNode;
-    /** Dropdown menu content. */
     content: ReactNode;
-    /** Additional classes for the dropdown wrapper. */
     className?: string;
-    /** Additional classes for the trigger button. */
     buttonClassName?: string;
-    /** Additional classes for the dropdown content panel. */
     dropdownClassName?: string;
     /** Trigger edge the menu lines up with. Position is computed, so a `left-0` class cannot do this. */
     align?: "start" | "end";
-    /** Names this dropdown for the in-page agent. Without it the menu publishes nothing — two on one screen would share a name. */
+    /** Names this dropdown for the in-page agent; without it the menu publishes nothing. */
     namespace?: string;
 }
 export declare const DefaultDropdown: ({ value, trigger, content, className, buttonClassName, dropdownClassName, align, namespace, }: DropdownProps) => import("react/jsx-runtime").JSX.Element;
-/**
- * Dropdown. Resolves to a route-scoped override when a `page/**\/_overrides.tsx`
- * in the route's ancestry declares one, otherwise renders {@link DefaultDropdown}.
- */
 export declare const Dropdown: import("react").ComponentType<DropdownProps>;

package/types/ui/Empty.d.ts

@@ -1,20 +1,13 @@
 import type { ReactNode } from "react";
 export interface EmptyProps {
-    /** Additional classes for the empty-state body. */
     className?: string;
-    /** The mark above the description. */
     icon?: ReactNode;
-    /** Custom description. Defaults to the localized base.noData label. */
+    /** Defaults to the localized `base.noData` label. */
     description?: ReactNode;
-    /** Optional content rendered below the empty-state body. */
+    /** Rendered below the empty-state body. */
     children?: ReactNode;
-    /** Minimum empty-state height in pixels. */
+    /** In pixels. */
     minHeight?: number;
 }
 export declare const DefaultEmpty: ({ className, icon, description, children, minHeight }: EmptyProps) => import("react/jsx-runtime").JSX.Element;
-/**
- * Empty-state placeholder. Resolves to a route-scoped override when a
- * `page/**\/_overrides.tsx` in the route's ancestry declares one, otherwise
- * renders {@link DefaultEmpty}.
- */
 export declare const Empty: import("react").ComponentType<EmptyProps>;

package/types/ui/Field/Collection.d.ts

@@ -29,22 +29,7 @@ export interface TextListProps {
     maxTextlength?: number;
 }
 export declare const TextList: ({ label, desc, labelClassName, className, value, onChange, placeholder, disabled, transform, minlength, maxlength, minTextlength, maxTextlength, validate, inputClassName, }: TextListProps) => import("react/jsx-runtime").JSX.Element;
-export interface TagsProps {
-    label?: string;
-    desc?: string;
-    labelClassName?: string;
-    className?: string;
-    value: string[] | null;
-    onChange: (value: string[]) => void;
-    inputClassName?: string;
-    placeholder?: string;
-    disabled?: boolean;
-    transform?: (value: string) => string;
-    validate?: (text: string) => boolean | string;
-    minlength?: number;
-    maxlength?: number;
-    minTextlength?: number;
-    maxTextlength?: number;
+export interface TagsProps extends TextListProps {
     secret?: boolean;
 }
 export declare const Tags: ({ label, desc, labelClassName, className, value, onChange, placeholder, disabled, transform, minlength, maxlength, minTextlength, maxTextlength, validate, inputClassName, }: TagsProps) => import("react/jsx-runtime").JSX.Element;

package/types/ui/Field/Relation.d.ts

@@ -1,80 +1,53 @@
 import type { SliceMeta } from "akanjs/fetch";
 import type { ReactNode } from "react";
-export interface ParentProps<Light> {
+interface RelationProps<Light> {
     label?: string;
     desc?: string;
     labelClassName?: string;
-    selectClassName?: string;
     className?: string;
     disabled?: boolean;
     nullable?: boolean;
     initArgs?: any[];
-    value: Light | null;
     slice: SliceMeta;
-    onChange: (value: Light | null) => void;
     onSearch?: (text: string) => void;
     sortOption?: (a: Light, b: Light) => number;
+}
+export interface ParentProps<Light> extends RelationProps<Light> {
+    selectClassName?: string;
+    value: Light | null;
+    onChange: (value: Light | null) => void;
     renderOption: (model: Light) => ReactNode;
     renderSelected?: (value: Light) => ReactNode;
 }
 export declare const Parent: <Light extends {
     id: string;
 }>({ label, desc, labelClassName, selectClassName, className, nullable, disabled, initArgs, slice, value, onChange, onSearch, sortOption, renderOption, renderSelected, }: ParentProps<Light>) => import("react/jsx-runtime").JSX.Element;
-export interface ParentIdProps<Light> {
-    label?: string;
-    desc?: string;
-    labelClassName?: string;
-    className?: string;
+export interface ParentIdProps<Light> extends RelationProps<Light> {
     selectClassName?: string;
-    disabled?: boolean;
-    nullable?: boolean;
-    initArgs?: any[];
     value: string | null;
-    slice: SliceMeta;
     onChange: (id: string | null, model: Light | null) => void;
-    onSearch?: (text: string) => void;
-    sortOption?: (a: Light, b: Light) => number;
     renderOption?: (model: Light) => ReactNode;
     renderSelected?: (value: Light) => ReactNode;
 }
 export declare const ParentId: <Light extends {
     id: string;
 }>({ label, desc, className, selectClassName, labelClassName, nullable, disabled, initArgs, slice, value, onChange, onSearch, sortOption, renderOption, renderSelected, }: ParentIdProps<Light>) => import("react/jsx-runtime").JSX.Element;
-export interface ChildrenProps<Light> {
-    label?: string;
-    desc?: string;
-    labelClassName?: string;
+export interface ChildrenProps<Light> extends RelationProps<Light> {
     selectClassName?: string;
-    className?: string;
-    disabled?: boolean;
-    nullable?: boolean;
-    initArgs?: any[];
     value: Light[] | null;
     onChange: (value: Light[]) => void;
-    onSearch?: (text: string) => void;
-    slice: SliceMeta;
-    sortOption?: (a: Light, b: Light) => number;
     renderOption: (model: Light) => ReactNode;
     renderSelected?: (value: Light) => ReactNode;
 }
 export declare const Children: <Light extends {
     id: string;
 }>({ label, desc, labelClassName, selectClassName, className, nullable, disabled, initArgs, slice, value, onChange, onSearch, sortOption, renderOption, renderSelected, }: ChildrenProps<Light>) => import("react/jsx-runtime").JSX.Element;
-export interface ChildrenIdProps<Light> {
-    label?: string;
-    desc?: string;
-    labelClassName?: string;
-    className?: string;
-    disabled?: boolean;
-    nullable?: boolean;
-    initArgs?: any[];
+export interface ChildrenIdProps<Light> extends RelationProps<Light> {
     value: string[] | null;
-    slice: SliceMeta;
     onChange: (value: string[]) => void;
-    onSearch?: (text: string) => void;
-    sortOption?: (a: Light, b: Light) => number;
     renderOption: (model: Light) => ReactNode;
 }
 export declare const ChildrenId: <Light extends {
     id: string;
 }>({ label, desc, labelClassName, className, nullable, disabled, initArgs, slice, value, onChange, onSearch, sortOption, renderOption, }: ChildrenIdProps<Light>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/types/ui/Field/Text.d.ts

@@ -1,4 +1,5 @@
-export interface TextProps {
+export declare const lengthValidator: (l: (key: string, param?: Record<string, string | number>) => string, minlength: number, maxlength: number, validate?: (text: string) => boolean | string) => (text: string) => string | boolean;
+interface TextFieldProps {
     label?: string;
     desc?: string;
     labelClassName?: string;
@@ -14,83 +15,25 @@ export interface TextProps {
     minlength?: number;
     maxlength?: number;
     onPressEnter?: () => void;
+}
+export interface TextProps extends TextFieldProps {
     inputStyleType?: "bordered" | "borderless" | "underline";
 }
 export declare const Text: ({ label, desc, labelClassName, className, value, onChange, placeholder, nullable, disabled, minlength, maxlength, transform, validate, onPressEnter, inputClassName, inputStyleType, }: TextProps) => import("react/jsx-runtime").JSX.Element;
-export interface TextAreaProps {
-    label?: string;
-    desc?: string;
-    labelClassName?: string;
-    className?: string;
-    value: string | null;
-    onChange: (value: string) => void;
-    inputClassName?: string;
-    placeholder?: string;
-    nullable?: boolean;
-    disabled?: boolean;
-    transform?: (value: string) => string;
-    validate?: (text: string) => boolean | string;
+export interface TextAreaProps extends TextFieldProps {
     rows?: number;
-    minlength?: number;
-    maxlength?: number;
-    onPressEnter?: () => void;
 }
 export declare const TextArea: ({ label, desc, labelClassName, className, value, onChange, placeholder, nullable, disabled, rows, minlength, maxlength, transform, validate, onPressEnter, inputClassName, }: TextAreaProps) => import("react/jsx-runtime").JSX.Element;
-export interface EmailProps {
-    label?: string;
-    desc?: string;
-    labelClassName?: string;
-    className?: string;
-    value: string | null;
-    onChange: (value: string) => void;
-    inputClassName?: string;
-    placeholder?: string;
-    nullable?: boolean;
-    disabled?: boolean;
-    transform?: (value: string) => string;
-    validate?: (text: string) => boolean | string;
-    minlength?: number;
-    maxlength?: number;
-    onPressEnter?: () => void;
+export interface EmailProps extends TextFieldProps {
     inputStyleType?: "bordered" | "borderless" | "underline";
 }
 export declare const Email: ({ label, desc, labelClassName, className, value, onChange, placeholder, nullable, disabled, minlength, maxlength, transform, validate, onPressEnter, inputClassName, inputStyleType, }: EmailProps) => import("react/jsx-runtime").JSX.Element;
-export interface PhoneProps {
-    label?: string;
-    desc?: string;
-    labelClassName?: string;
-    className?: string;
-    value: string | null;
-    onChange: (value: string) => void;
-    inputClassName?: string;
-    placeholder?: string;
-    nullable?: boolean;
-    disabled?: boolean;
-    transform?: (value: string) => string;
-    validate?: (text: string) => boolean | string;
-    minlength?: number;
-    maxlength?: number;
-    onPressEnter?: () => void;
-}
+export type PhoneProps = TextFieldProps;
 export declare const Phone: ({ label, desc, labelClassName, className, value, onChange, placeholder, nullable, disabled, maxlength, transform, validate, onPressEnter, inputClassName, }: PhoneProps) => import("react/jsx-runtime").JSX.Element;
-export interface PasswordProps {
-    label?: string;
-    desc?: string;
-    labelClassName?: string;
-    className?: string;
-    value: string | null;
-    onChange: (value: string) => void;
+export interface PasswordProps extends TextFieldProps {
     confirmValue?: string | null;
     onChangeConfirm?: (value: string) => void;
-    inputClassName?: string;
-    placeholder?: string;
-    nullable?: boolean;
-    disabled?: boolean;
-    transform?: (value: string) => string;
-    validate?: (text: string) => boolean | string;
-    minlength?: number;
-    maxlength?: number;
-    onPressEnter?: () => void;
     showConfirm?: boolean;
 }
 export declare const Password: ({ label, desc, labelClassName, className, value, onChange, confirmValue, onChangeConfirm, placeholder, nullable, disabled, minlength, maxlength, transform, validate, onPressEnter, inputClassName, showConfirm, }: PasswordProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/types/ui/Field/index.d.ts

@@ -1,23 +1,14 @@
 import type { ReactNode } from "react";
 export interface FieldProps {
     className?: string;
-    /** Wrapper around the field controls. */
     containerClassName?: string;
     labelClassName?: string;
-    /** Section label shown above the controls. */
     label?: ReactNode;
-    /** Optional help text shown in the label tooltip. */
     desc?: ReactNode;
     /** Marks the field as optional in the label. */
     nullable?: boolean;
-    /** Field control content. */
     children?: ReactNode;
 }
-/**
- * The form-field namespace. `Object.assign` rather than `Field.X = X` per file, because the members now live
- * beside each other by kind — the assignment form only works where the function and every member are one file,
- * which is how this reached 1600 lines.
- */
 export declare const Field: (({ className, containerClassName, labelClassName, label, desc, nullable, children, }: FieldProps) => import("react/jsx-runtime").JSX.Element) & {
     Label: ({ className, label, desc, unit, nullable, mode }: import("./Label.d.ts").LabelProps) => import("react/jsx-runtime").JSX.Element;
     List: <Item>({ className, labelClassName, label, desc, value, onChange, onAdd, nullable, renderItem, }: import("./Collection.d.ts").ListProps<Item>) => import("react/jsx-runtime").JSX.Element;

package/types/ui/Field/lightRefCache.d.ts

@@ -0,0 +1,11 @@
+interface LightRow {
+    id: string;
+}
+export declare class LightRefCache {
+    #private;
+    static get<Light extends LightRow>(refName: string, id: string): Light | null;
+    static subscribe(listener: (refName: string, id: string) => void): () => void;
+    static load(refName: string, ids: string[]): void;
+    static reset(): void;
+}
+export {};

package/types/ui/Field/useRelationOptions.d.ts

@@ -0,0 +1,28 @@
+import { DataList } from "akanjs/base";
+import type { SliceMeta } from "akanjs/fetch";
+import { type ReactNode } from "react";
+export interface RelationOptionsSource<Light extends {
+    id: string;
+}> {
+    slice: SliceMeta;
+    /** Held ids, whether or not the option list carries them. */
+    ids: string[];
+    /** Rows the control was handed outright, which a `Light`-valued field's own value already is. */
+    pinned?: (Light | null)[];
+    initArgs?: any[];
+    sortOption?: (a: Light, b: Light) => number;
+    renderOption?: (model: Light) => ReactNode;
+}
+export declare const useRelationOptions: <Light extends {
+    id: string;
+}>({ slice, ids, pinned, initArgs, sortOption, renderOption, }: RelationOptionsSource<Light>) => {
+    models: DataList<Light>;
+    options: {
+        label: string;
+        value: string;
+    }[];
+    optionLabel: (model: Light) => string;
+    listLoading: boolean;
+    load: () => Promise<void>;
+    read: () => DataList<Light>;
+};

package/types/ui/Image.d.ts

@@ -6,32 +6,28 @@ type ImageLikeFile = ProtoLightFile | {
     abstractData?: string | null;
 } | null;
 type NativeImageProps = Omit<ImgHTMLAttributes<HTMLImageElement>, "alt" | "src" | "srcSet"> & {
-    /** Fill the parent box when the renderer supports fill-style images. */
     fill?: boolean;
-    /** Placeholder mode passed through to image renderers. */
     placeholder?: string;
-    /** Base64 or low-quality preview data used for blur placeholders. */
     blurDataURL?: string;
 };
 type AkanImageProps = NativeImageProps & {
-    /** Direct image URL. Takes precedence over file.url. */
+    /** Takes precedence over `file.url`. */
     src?: string;
-    /** Akan file object or file-like value with url and imageSize metadata. */
     file?: ImageLikeFile;
-    /** Low-quality preview data. Overrides file.abstractData when provided. */
+    /** Overrides `file.abstractData`. */
     abstractData?: string | null;
-    /** Accessible alt text. Defaults to "image" when omitted. */
+    /** Defaults to "image". */
     alt?: string;
-    /** Image optimizer quality. Defaults to 75. */
+    /** Optimizer quality, 75 by default. */
     quality?: number;
-    /** Mark image as high priority and eager-loading. */
+    /** Loads eagerly at high fetch priority, and preloads during SSR. */
     priority?: boolean;
-    /** Preload image resource in SSR mode. */
+    /** Preloads the resource during SSR. */
     preload?: boolean;
-    /** Skip Akan image optimization and use the original src. */
+    /** Serves the original `src`, skipping the optimizer. */
     unoptimized?: boolean;
 };
-export declare const Image: ({ src, file, className, abstractData, alt, quality, priority, preload, unoptimized, ...props }: AkanImageProps & ({
+export declare const Image: (imageProps: AkanImageProps & ({
     src?: string;
     file?: ProtoLightFile;
     abstractData?: string | null;

package/types/ui/InfiniteScroll.d.ts

@@ -3,13 +3,9 @@ export interface InfiniteScrollProps {
     hasMore: boolean;
     onLoadMore: () => Promise<void>;
     children: React.ReactNode;
-    /**
-     * Load earlier rows above the ones in hand, preserving the reading position across the prepend. Assumes
-     * normal column flow. It does not scroll anywhere at mount, so a list meant to open at its newest row scrolls
-     * itself — and until it does, the sentinel is on screen and loads one window unasked.
-     */
+    /** Loads earlier rows above, keeping the reading position. It never scrolls at mount, so until the list scrolls
+     *  itself to its newest row the sentinel is on screen and loads one window unasked. */
     reverse?: boolean;
-    /** The mark shown while the next window is loading. */
     loading?: ReactNode;
 }
 export declare const InfiniteScroll: ({ hasMore, onLoadMore, children, reverse, loading }: InfiniteScrollProps) => import("react/jsx-runtime").JSX.Element;

package/types/ui/Input.d.ts

@@ -1,25 +1,23 @@
-import React, { type ChangeEvent, type InputHTMLAttributes, type KeyboardEvent, type RefObject, type TextareaHTMLAttributes } from "react";
+import React, { type ChangeEvent, type InputHTMLAttributes, type KeyboardEvent, type ReactNode, type RefObject, type TextareaHTMLAttributes } from "react";
+export declare const invalidMessageOf: (skip: unknown, result: boolean | string | undefined, l: (key: "base.invalidValueError") => string) => string | null | undefined;
+export declare const InvalidMessage: ({ message }: {
+    message: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element | null;
 export type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "onChange"> & {
-    /** Visual input style. */
     inputStyleType?: "bordered" | "borderless" | "underline";
-    /** Ref forwarded to the native input element. */
     inputRef?: RefObject<HTMLInputElement | null>;
-    /** Controlled input value. */
     value: string;
-    /** Allow empty value without warning status. */
+    /** Allows an empty value without the warning status. */
     nullable?: boolean;
-    /** Optional leading icon. */
     icon?: React.ReactNode;
     iconClassName?: string;
     inputClassName?: string;
     inputWrapperClassName?: string;
-    /** Called when Enter is pressed. */
     onPressEnter?: (value: any, event: KeyboardEvent<HTMLInputElement>) => void;
-    /** Returns true for valid input, false/string for invalid input. */
+    /** `true` is valid; `false` or a message string is invalid. */
     validate?: (value: string) => boolean | string;
-    /** Controlled value change callback. */
     onChange?: (value: string, e?: ChangeEvent<HTMLInputElement>) => void;
-    /** Called when Escape is pressed after blurring the input. */
+    /** Called after Escape blurs the input. */
     onPressEscape?: (e: KeyboardEvent<HTMLInputElement>) => void;
 };
 export type TextAreaProps = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "type" | "onChange" | "onPressEnter"> & {
@@ -79,11 +77,6 @@ export type CheckboxProps = Omit<InputHTMLAttributes<HTMLInputElement>, "onChang
     checked: boolean;
     onChange: (checked: boolean, e: ChangeEvent<HTMLInputElement>) => void;
 };
-/**
- * Text input plus its field variants. Each leaf resolves to a route-scoped override when a
- * `page/**\/_overrides.tsx` in the route's ancestry declares one (slots `Input`, `InputTextArea`,
- * `InputPassword`, `InputEmail`, `InputNumber`, `InputCheckbox`), otherwise renders the default.
- */
 export declare const Input: React.ComponentType<InputProps> & {
     TextArea: React.ComponentType<TextAreaProps>;
     Password: React.ComponentType<PasswordProps>;

package/types/ui/Layout/Role.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from "react";
+export interface TemplateProps {
+    className?: string;
+    children?: ReactNode;
+}
+export declare const Template: ({ className, children }: TemplateProps) => import("react/jsx-runtime").JSX.Element;
+export interface UnitProps {
+    className?: string;
+    children: ReactNode;
+    /** Makes the whole unit a link. */
+    href?: string;
+}
+export declare const Unit: ({ className, children, href }: UnitProps) => import("react/jsx-runtime").JSX.Element;
+export interface ViewProps {
+    className?: string;
+    children: ReactNode;
+}
+export declare const View: ({ className, children }: ViewProps) => import("react/jsx-runtime").JSX.Element;
+export interface ZoneProps {
+    className?: string;
+    children: ReactNode;
+}
+export declare const Zone: ({ className, children }: ZoneProps) => import("react/jsx-runtime").JSX.Element;

package/types/ui/Layout/Sider.d.ts

@@ -11,3 +11,24 @@ export interface SiderProps {
     children?: ReactNode;
 }
 export declare const Sider: ({ className, bgClassName, trigger, header, close, children }: SiderProps) => import("react/jsx-runtime").JSX.Element;
+export interface LeftSiderProps {
+    className?: string;
+    children: ReactNode;
+    open: boolean;
+    width?: number | string;
+    /** Element that closes the drawer. `false` draws none. */
+    close?: ReactNode | false;
+    onCancel: () => void;
+}
+export declare const LeftSider: ({ className, children, open, width, close, onCancel }: LeftSiderProps) => import("react/jsx-runtime").JSX.Element;
+export interface RightSiderProps {
+    className?: string;
+    children: ReactNode;
+    open: boolean;
+    title?: ReactNode;
+    width?: number | string;
+    /** The mark inside the drawer's close control. `false` draws no control. */
+    close?: ReactNode | false;
+    onCancel: () => void;
+}
+export declare const RightSider: ({ className, children, open, title, width, close, onCancel }: RightSiderProps) => import("react/jsx-runtime").JSX.Element;

package/types/ui/Layout/TopInset.d.ts

@@ -5,3 +5,8 @@ export interface TopInsetProps {
     estimatedHeight?: number;
 }
 export declare const TopInset: ({ className, children, estimatedHeight }: TopInsetProps) => import("react/jsx-runtime").JSX.Element;
+export interface TopLeftActionProps {
+    className?: string;
+    children: ReactNode;
+}
+export declare const TopLeftAction: ({ className, children }: TopLeftActionProps) => import("react/jsx-runtime").JSX.Element | null;

package/types/ui/Layout/index.d.ts

@@ -5,11 +5,11 @@ export declare const Layout: {
     TopInset: ({ className, children, estimatedHeight }: import("./TopInset.d.ts").TopInsetProps) => import("react/jsx-runtime").JSX.Element;
     BottomTab: ({ className, tabs, height, renderTab }: import("./BottomTab.d.ts").BottomTabProps) => import("react/jsx-runtime").JSX.Element;
     BottomInset: ({ className, children, keyboardSticky, contentAnchor, role, estimatedHeight, frameScope, frameSource, frameCache, }: import("./BottomInset.d.ts").BottomInsetProps) => import("react/jsx-runtime").JSX.Element;
-    Template: ({ className, children }: import("./Template.d.ts").TemplateProps) => import("react/jsx-runtime").JSX.Element;
-    Unit: ({ className, children, href }: import("./Unit.d.ts").UnitProps) => import("react/jsx-runtime").JSX.Element;
-    View: ({ className, children }: import("./View.d.ts").ViewProps) => import("react/jsx-runtime").JSX.Element;
-    Zone: ({ className, children }: import("./Zone.d.ts").ZoneProps) => import("react/jsx-runtime").JSX.Element;
-    TopLeftAction: ({ className, children }: import("./TopLeftAction.d.ts").TopLeftActionProps) => import("react/jsx-runtime").JSX.Element | null;
-    LeftSider: ({ className, children, open, width, close, onCancel }: import("./LeftSider.d.ts").LeftSiderProps) => import("react/jsx-runtime").JSX.Element;
-    RightSider: ({ className, children, open, title, width, close, onCancel }: import("./RightSider.d.ts").RightSiderProps) => import("react/jsx-runtime").JSX.Element;
+    Template: ({ className, children }: import("./Role.d.ts").TemplateProps) => import("react/jsx-runtime").JSX.Element;
+    Unit: ({ className, children, href }: import("./Role.d.ts").UnitProps) => import("react/jsx-runtime").JSX.Element;
+    View: ({ className, children }: import("./Role.d.ts").ViewProps) => import("react/jsx-runtime").JSX.Element;
+    Zone: ({ className, children }: import("./Role.d.ts").ZoneProps) => import("react/jsx-runtime").JSX.Element;
+    TopLeftAction: ({ className, children }: import("./TopInset.d.ts").TopLeftActionProps) => import("react/jsx-runtime").JSX.Element | null;
+    LeftSider: ({ className, children, open, width, close, onCancel }: import("./Sider.d.ts").LeftSiderProps) => import("react/jsx-runtime").JSX.Element;
+    RightSider: ({ className, children, open, title, width, close, onCancel }: import("./Sider.d.ts").RightSiderProps) => import("react/jsx-runtime").JSX.Element;
 };

package/types/ui/LegacyModal.d.ts

@@ -1,24 +1,13 @@
 import type { ReactNode } from "react";
 export interface LegacyModalProps {
-    /** Additional classes for the modal surface. */
     className?: string;
-    /** Optional modal title. */
     title?: string | ReactNode;
-    /** Optional action area, usually footer buttons. */
     action?: ReactNode;
-    /** Controlled open state. */
     open: boolean;
-    /** Called when the modal requests closing. */
     onCancel: () => void;
-    /** Additional classes for the content body. */
     bodyClassName?: string;
     children?: ReactNode;
-    /** Ask for close confirmation before dismissing. */
     confirmClose?: boolean;
 }
-/**
- * Previous akanjs modal skin: spring open/close and a drag-to-dismiss sheet on touch. Kept for screens
- * built around that motion. New work uses {@link Modal}, which takes the same props with no animation,
- * and unlike this one resolves through the `Modal` override slot.
- */
+/** Spring-animated, drag-to-dismiss skin. Unlike `Modal`, it does not resolve through the `Modal` override slot. */
 export declare const LegacyModal: ({ className, title, action, open, onCancel, bodyClassName, children, confirmClose, }: LegacyModalProps) => import("react/jsx-runtime").JSX.Element;

package/types/ui/Link/Action.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from "react";
+export interface ActionProps {
+    className?: string;
+    children?: ReactNode;
+}
+export declare const Back: ({ className, children }: ActionProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Close: ({ className, children }: ActionProps) => import("react/jsx-runtime").JSX.Element;
+export interface LangProps extends ActionProps {
+    lang: "ko" | "en" | (string & {});
+}
+export declare const Lang: ({ className, lang, children }: LangProps) => import("react/jsx-runtime").JSX.Element;

package/types/ui/Link/Anchor.d.ts

@@ -0,0 +1,20 @@
+import type { AnchorHTMLAttributes } from "react";
+export type CommonLinkProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & {
+    /** Omitted, or with `disabled`, Link renders a plain div around the same children. */
+    href?: string | null;
+    disabled?: boolean;
+    scrollToTop?: boolean;
+    /** Replaces the current history entry instead of pushing a new one. */
+    replace?: boolean;
+    /** Applied while the current path starts with `href`, or equals it with `activeExact`. */
+    activeClassName?: string;
+    activeExact?: boolean;
+    /** @deprecated Has no effect: neither renderer reads it. */
+    noCache?: boolean;
+};
+type AnchorProps = Omit<CommonLinkProps, "href" | "disabled"> & {
+    href: string;
+};
+export declare const CsrLink: ({ className, children, href, replace, activeClassName, scrollToTop, activeExact, noCache, ...props }: AnchorProps) => import("react/jsx-runtime").JSX.Element;
+export declare const SsrLink: ({ className, children, href, scrollToTop, replace, activeClassName, activeExact, noCache, ...props }: AnchorProps) => import("react/jsx-runtime").JSX.Element;
+export {};