@geektech/one 0.0.1 → 0.2.0

package/dist/loading/OneLoading.d.ts

@@ -0,0 +1,16 @@
+import { Component, type VNode } from '@geektech/tsone';
+import { type OneDataDisplayVariant } from '../data-display';
+import { type OneNamedStyle } from '../styles/shared';
+import type { OneComponentSize } from '../types';
+export interface OneLoadingProps {
+    size?: OneComponentSize;
+    variant?: OneDataDisplayVariant;
+    label?: string;
+    children?: Array<VNode | string>;
+}
+export declare const ONE_LOADING_STYLES: OneNamedStyle[];
+export declare class OneLoading extends Component<OneLoadingProps> {
+    protected initState(): object;
+    protected initStyles(): void;
+    protected render(): VNode;
+}

package/dist/loading/index.d.ts

@@ -0,0 +1,2 @@
+export { OneLoading } from './OneLoading';
+export type { OneLoadingProps } from './OneLoading';

package/dist/message/MessageOverlay.d.ts

@@ -0,0 +1,25 @@
+import { Component, type VNode } from '@geektech/tsone';
+import type { OneFeedbackVariant } from '../overlay';
+import { type OneNamedStyle } from '../styles/shared';
+import type { OneMessageOptions, OneMessagePlacement } from './types';
+export interface MessageOverlayProps extends Omit<OneMessageOptions, 'container'> {
+    variant: OneFeedbackVariant;
+    duration: number;
+    placement: OneMessagePlacement;
+    requestClose(): void;
+}
+export declare const ONE_MESSAGE_STYLES: OneNamedStyle[];
+interface MessageOverlayState {
+}
+export declare class MessageOverlay extends Component<MessageOverlayProps, MessageOverlayState> {
+    private timer;
+    mount(container: HTMLElement): void;
+    protected initState(): MessageOverlayState;
+    protected initStyles(): void;
+    protected onMounted(): void;
+    protected onUnmounted(): void;
+    setProps(props: Partial<MessageOverlayProps>): void;
+    protected render(): VNode;
+    private decorateGroup;
+}
+export {};

package/dist/message/OneMessage.d.ts

@@ -0,0 +1,19 @@
+import { Component, type VNode } from '@geektech/tsone';
+import type { OneMessageProps } from './types';
+interface OneMessageState {
+    internalOpen: boolean;
+}
+export declare class OneMessage extends Component<OneMessageProps, OneMessageState> {
+    private controller;
+    private viewMounted;
+    protected initState(): OneMessageState;
+    protected initStyles(): void;
+    protected onMounted(): void;
+    protected beforeUpdate(): void;
+    protected beforeUnmount(): void;
+    protected render(): VNode;
+    private createOverlay;
+    private synchronizeOverlay;
+    private requestClose;
+}
+export {};

package/dist/message/index.d.ts

@@ -0,0 +1,6 @@
+export { MessageOverlay, ONE_MESSAGE_STYLES } from './MessageOverlay';
+export { OneMessage } from './OneMessage';
+export { OneMessageService, createOneMessageService, oneMessage, } from './service';
+export { OneMessageTimer } from './timer';
+export type { OneTimerScheduler } from './timer';
+export type { OneMessageOptions, OneMessagePlacement, OneMessageProps, } from './types';

package/dist/message/normalize.d.ts

@@ -0,0 +1,8 @@
+import type { OneFeedbackVariant } from '../overlay';
+import type { OneMessageOptions, OneMessagePlacement } from './types';
+export interface NormalizedOneMessageOptions extends Omit<OneMessageOptions, 'variant' | 'duration' | 'placement'> {
+    variant: OneFeedbackVariant;
+    duration: number;
+    placement: OneMessagePlacement;
+}
+export declare function normalizeOneMessageOptions(options: OneMessageOptions): NormalizedOneMessageOptions;

package/dist/message/service.d.ts

@@ -0,0 +1,17 @@
+import { type OneOverlayHandle, type OneOverlayHost } from '../overlay';
+import type { OneMessageOptions } from './types';
+type OneMessageShortcutOptions = Omit<OneMessageOptions, 'content' | 'variant'>;
+export declare class OneMessageService {
+    private readonly suppliedHost?;
+    constructor(suppliedHost?: OneOverlayHost | undefined);
+    open(options: OneMessageOptions): OneOverlayHandle<OneMessageOptions>;
+    info(content: string, options?: OneMessageShortcutOptions): OneOverlayHandle<OneMessageOptions>;
+    success(content: string, options?: OneMessageShortcutOptions): OneOverlayHandle<OneMessageOptions>;
+    warning(content: string, options?: OneMessageShortcutOptions): OneOverlayHandle<OneMessageOptions>;
+    error(content: string, options?: OneMessageShortcutOptions): OneOverlayHandle<OneMessageOptions>;
+    close(id: string): void;
+    closeAll(): void;
+}
+export declare function createOneMessageService(host?: OneOverlayHost): OneMessageService;
+export declare const oneMessage: OneMessageService;
+export {};

package/dist/message/timer.d.ts

@@ -0,0 +1,21 @@
+export interface OneTimerScheduler {
+    now(): number;
+    set(callback: () => void, delay: number): unknown;
+    clear(handle: unknown): void;
+}
+export declare class OneMessageTimer {
+    private readonly scheduler;
+    private readonly onElapsed;
+    private handle;
+    private remaining;
+    private startedAt;
+    private paused;
+    private disposed;
+    constructor(duration: number, scheduler: OneTimerScheduler | undefined, onElapsed: () => void);
+    pause(): void;
+    resume(): void;
+    reset(duration: number): void;
+    dispose(): void;
+    private schedule;
+    private clear;
+}

package/dist/message/types.d.ts

@@ -0,0 +1,14 @@
+import type { OneFeedbackVariant, OneOverlayContainer } from '../overlay';
+export type OneMessagePlacement = 'top-start' | 'top' | 'top-end' | 'bottom-start' | 'bottom' | 'bottom-end';
+export interface OneMessageOptions {
+    content: string;
+    variant?: OneFeedbackVariant;
+    duration?: number;
+    closable?: boolean;
+    placement?: OneMessagePlacement;
+    container?: OneOverlayContainer;
+}
+export interface OneMessageProps extends OneMessageOptions {
+    open?: boolean;
+    defaultOpen?: boolean;
+}

package/dist/navigation/index.d.ts

@@ -0,0 +1,2 @@
+export { normalizeNonNegativeInteger, normalizePositiveInteger, normalizePositiveIntegerList, } from './normalize';
+export type { OneNavigationChangeEvent } from './types';

package/dist/navigation/normalize.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeNonNegativeInteger(value: unknown, fallback: number): number;
+export declare function normalizePositiveInteger(value: unknown, fallback: number): number;
+export declare function normalizePositiveIntegerList(values: unknown, fallback: readonly number[]): number[];

package/dist/navigation/types.d.ts

@@ -0,0 +1,4 @@
+export interface OneNavigationChangeEvent<TValue> {
+    value: TValue;
+    originalEvent: Event;
+}

package/dist/overlay/container.d.ts

@@ -0,0 +1,2 @@
+import type { OneOverlayContainer } from './types';
+export declare function resolveOneOverlayContainer(container?: OneOverlayContainer, targetDocument?: Document | null): HTMLElement;

package/dist/overlay/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class OneOverlayEnvironmentError extends Error {
+    constructor(message?: string);
+}
+export declare class OneOverlayContainerError extends Error {
+    constructor(message: string);
+}
+export declare class OneTooltipTriggerError extends Error {
+    constructor(message?: string);
+}

package/dist/overlay/host.d.ts

@@ -0,0 +1,16 @@
+import type { OneOverlayHandle, OneOverlayHost, OneOverlayKind, OneOverlayOpenRequest } from './types';
+export declare class DomOneOverlayHost implements OneOverlayHost {
+    private readonly targetDocument;
+    private readonly entries;
+    private readonly records;
+    private sequence;
+    constructor(targetDocument: Document);
+    open<TOptions extends object>(request: OneOverlayOpenRequest<TOptions>): OneOverlayHandle<TOptions>;
+    close(id: string): void;
+    closeAll(kind?: OneOverlayKind): void;
+    isTop(id: string): boolean;
+    private getOrCreateEntry;
+    private getOrCreateGroup;
+    private removeRecord;
+}
+export declare function getDefaultOneOverlayHost(targetDocument?: Document): OneOverlayHost;

package/dist/overlay/index.d.ts

@@ -0,0 +1,7 @@
+export { resolveOneOverlayContainer } from './container';
+export { OneOverlayContainerError, OneOverlayEnvironmentError, OneTooltipTriggerError, } from './errors';
+export { DomOneOverlayHost, getDefaultOneOverlayHost } from './host';
+export { OneOverlayMountController } from './mount-controller';
+export { OneFloatingPositioner } from './positioner';
+export type { OneOverlayPositionRequest, OneOverlayPositionResult, OneOverlayPositioner, OneOverlayRect, } from './positioner';
+export type { OneFeedbackVariant, OneManagedOverlay, OneOverlayContainer, OneOverlayFactory, OneOverlayFactoryContext, OneOverlayHandle, OneOverlayHost, OneOverlayKind, OneOverlayOpenRequest, OneOverlayPlacement, } from './types';

package/dist/overlay/mount-controller.d.ts

@@ -0,0 +1,13 @@
+import type { OneOverlayContainer, OneOverlayFactory, OneOverlayHost, OneOverlayKind } from './types';
+export declare class OneOverlayMountController<TOptions extends object> {
+    private readonly host;
+    private readonly kind;
+    private readonly factory;
+    private readonly group?;
+    private handle;
+    constructor(host: OneOverlayHost, kind: OneOverlayKind, factory: OneOverlayFactory<TOptions>, group?: string | undefined);
+    open(container?: OneOverlayContainer): void;
+    update(options: Partial<TOptions>): void;
+    close(): void;
+    isOpen(): boolean;
+}

package/dist/overlay/positioner.d.ts

@@ -0,0 +1,36 @@
+import type { OneOverlayPlacement } from './types';
+export interface OneOverlayRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface OneOverlayPositionRequest {
+    reference: OneOverlayRect;
+    floating: OneOverlayRect;
+    boundary: OneOverlayRect;
+    placement: OneOverlayPlacement;
+    offset: number;
+    padding: number;
+}
+export interface OneOverlayPositionResult {
+    x: number;
+    y: number;
+    placement: OneOverlayPlacement;
+    arrow: {
+        x?: number;
+        y?: number;
+    };
+}
+export interface OneOverlayPositioner {
+    compute(request: OneOverlayPositionRequest): OneOverlayPositionResult;
+    autoUpdate(reference: HTMLElement, floating: HTMLElement, update: () => void): () => void;
+}
+export declare class OneFloatingPositioner implements OneOverlayPositioner {
+    compute(request: OneOverlayPositionRequest): OneOverlayPositionResult;
+    autoUpdate(reference: HTMLElement, floating: HTMLElement, update: () => void): () => void;
+}

package/dist/overlay/types.d.ts

@@ -0,0 +1,32 @@
+export type OneFeedbackVariant = 'info' | 'success' | 'warning' | 'error';
+export type OneOverlayContainer = HTMLElement | (() => HTMLElement | null);
+export type OneOverlayPlacement = 'top-start' | 'top' | 'top-end' | 'right-start' | 'right' | 'right-end' | 'bottom-start' | 'bottom' | 'bottom-end' | 'left-start' | 'left' | 'left-end';
+export type OneOverlayKind = 'message' | 'dialog' | 'tooltip';
+export interface OneOverlayHandle<TOptions extends object> {
+    readonly id: string;
+    update(options: Partial<TOptions>): void;
+    close(): void;
+}
+export interface OneManagedOverlay<TOptions extends object> {
+    update(options: Partial<TOptions>): void;
+    destroy(): void;
+}
+export interface OneOverlayFactoryContext {
+    id: string;
+    slot: HTMLElement;
+    requestClose(): void;
+    isTop(): boolean;
+}
+export type OneOverlayFactory<TOptions extends object> = (context: OneOverlayFactoryContext) => OneManagedOverlay<TOptions>;
+export interface OneOverlayOpenRequest<TOptions extends object> {
+    kind: OneOverlayKind;
+    group?: string;
+    container?: OneOverlayContainer;
+    factory: OneOverlayFactory<TOptions>;
+}
+export interface OneOverlayHost {
+    open<TOptions extends object>(request: OneOverlayOpenRequest<TOptions>): OneOverlayHandle<TOptions>;
+    close(id: string): void;
+    closeAll(kind?: OneOverlayKind): void;
+    isTop(id: string): boolean;
+}

package/dist/pagination/OnePagination.d.ts

@@ -0,0 +1,42 @@
+import { Component, type VNode } from '@geektech/tsone';
+import { type OneNamedStyle } from '../styles/shared';
+export interface OnePaginationChangeEvent {
+    page: number;
+    pageSize: number;
+    originalEvent: Event;
+}
+export interface OnePaginationProps {
+    total: number;
+    page?: number;
+    defaultPage?: number;
+    pageSize?: number;
+    defaultPageSize?: number;
+    pageSizeOptions?: readonly number[];
+    siblingCount?: number;
+    showQuickJumper?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+}
+interface OnePaginationState {
+    internalPage: number;
+    internalPageSize: number;
+    jumpValue: string;
+}
+export declare const ONE_PAGINATION_STYLES: OneNamedStyle[];
+export declare class OnePagination extends Component<OnePaginationProps, OnePaginationState> {
+    protected initState(): OnePaginationState;
+    protected initStyles(): void;
+    protected render(): VNode;
+    private effectivePageSize;
+    private pageCount;
+    private effectivePage;
+    private sizeOptions;
+    private renderPageButton;
+    private renderEllipsis;
+    private handleSizeChange;
+    private handleJumpInput;
+    private handleJumpKeydown;
+    private requestChange;
+    private submitJump;
+}
+export {};

package/dist/pagination/index.d.ts

@@ -0,0 +1,2 @@
+export { ONE_PAGINATION_STYLES, OnePagination, type OnePaginationChangeEvent, type OnePaginationProps, } from './OnePagination';
+export { createOnePaginationTokens, type OnePaginationToken } from './tokens';

package/dist/pagination/tokens.d.ts

@@ -0,0 +1,2 @@
+export type OnePaginationToken = number | 'ellipsis-start' | 'ellipsis-end';
+export declare function createOnePaginationTokens(pageCount: number, page: number, siblingCount: number): OnePaginationToken[];

package/dist/progress/OneProgress.d.ts

@@ -0,0 +1,15 @@
+import { Component, type VNode } from '@geektech/tsone';
+import { type OneDataDisplayVariant } from '../data-display';
+import { type OneNamedStyle } from '../styles/shared';
+export interface OneProgressProps {
+    percent?: number;
+    variant?: OneDataDisplayVariant;
+    showText?: boolean;
+    ariaLabel?: string;
+}
+export declare const ONE_PROGRESS_STYLES: OneNamedStyle[];
+export declare class OneProgress extends Component<OneProgressProps> {
+    protected initState(): object;
+    protected initStyles(): void;
+    protected render(): VNode;
+}

package/dist/progress/index.d.ts

@@ -0,0 +1,2 @@
+export { OneProgress } from './OneProgress';
+export type { OneProgressProps } from './OneProgress';

package/dist/radio/OneRadio.d.ts

@@ -0,0 +1,32 @@
+import { Component, type VNode } from '@geektech/tsone';
+import { type OneNamedStyle } from '../styles/shared';
+export interface OneRadioProps {
+    value?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    name?: string;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+    children?: Array<VNode | string>;
+}
+interface OneRadioState {
+    internalChecked: boolean;
+    revision: number;
+}
+export declare const ONE_RADIO_STYLES: OneNamedStyle[];
+export declare class OneRadio extends Component<OneRadioProps, OneRadioState> {
+    private fieldContext;
+    private unsubscribe;
+    protected initState(): OneRadioState;
+    protected initStyles(): void;
+    protected beforeMount(): void;
+    protected onMounted(): void;
+    protected onUnmounted(): void;
+    protected onUpdated(): void;
+    protected render(): VNode;
+    private getChecked;
+    private emitChecked;
+}
+export {};

package/dist/radio/OneRadioGroup.d.ts

@@ -0,0 +1,30 @@
+import { Component, type VNode } from '@geektech/tsone';
+import type { OneSelectOption } from '../select';
+import { type OneNamedStyle } from '../styles/shared';
+export interface OneRadioGroupProps {
+    options: readonly OneSelectOption[];
+    value?: string;
+    defaultValue?: string;
+    name?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+}
+interface OneRadioGroupState {
+    internalValue: string;
+    revision: number;
+}
+export declare const ONE_RADIO_GROUP_STYLES: OneNamedStyle[];
+export declare class OneRadioGroup extends Component<OneRadioGroupProps, OneRadioGroupState> {
+    private fieldContext;
+    private unsubscribe;
+    protected initState(): OneRadioGroupState;
+    protected initStyles(): void;
+    protected beforeMount(): void;
+    protected onMounted(): void;
+    protected onUnmounted(): void;
+    protected render(): VNode;
+    private getValue;
+    private select;
+}
+export {};

package/dist/radio/index.d.ts

@@ -0,0 +1,4 @@
+export { OneRadio } from './OneRadio';
+export type { OneRadioProps } from './OneRadio';
+export { OneRadioGroup } from './OneRadioGroup';
+export type { OneRadioGroupProps } from './OneRadioGroup';

package/dist/rate/OneRate.d.ts

@@ -0,0 +1,28 @@
+import { Component, type VNode } from '@geektech/tsone';
+import { type OneNamedStyle } from '../styles/shared';
+export interface OneRateValueEvent {
+    value: number;
+    originalEvent: Event;
+}
+export interface OneRateProps {
+    value?: number;
+    defaultValue?: number;
+    count?: number;
+    disabled?: boolean;
+    readonly?: boolean;
+    allowClear?: boolean;
+    ariaLabel?: string;
+}
+interface OneRateState {
+    internalValue: number;
+}
+export declare const ONE_RATE_STYLES: OneNamedStyle[];
+export declare function normalizeOneRateValue(value: number | undefined, fallback: number): number;
+export declare class OneRate extends Component<OneRateProps, OneRateState> {
+    protected initState(): OneRateState;
+    protected initStyles(): void;
+    protected render(): VNode;
+    private getCount;
+    private emitValue;
+}
+export {};

package/dist/rate/index.d.ts

@@ -0,0 +1,2 @@
+export { OneRate } from './OneRate';
+export type { OneRateProps, OneRateValueEvent } from './OneRate';

package/dist/skeleton/OneSkeleton.d.ts

@@ -0,0 +1,16 @@
+import { Component, type VNode } from '@geektech/tsone';
+import { type OneNamedStyle } from '../styles/shared';
+export interface OneSkeletonProps {
+    rows?: number;
+    title?: boolean;
+    avatar?: boolean;
+    animated?: boolean;
+    widths?: readonly string[];
+    ariaLabel?: string;
+}
+export declare const ONE_SKELETON_STYLES: OneNamedStyle[];
+export declare class OneSkeleton extends Component<OneSkeletonProps> {
+    protected initState(): object;
+    protected initStyles(): void;
+    protected render(): VNode;
+}

package/dist/skeleton/index.d.ts

@@ -0,0 +1,2 @@
+export { OneSkeleton } from './OneSkeleton';
+export type { OneSkeletonProps } from './OneSkeleton';

package/dist/slider/OneSlider.d.ts

@@ -0,0 +1,29 @@
+import { Component, type VNode } from '@geektech/tsone';
+import { type OneNamedStyle } from '../styles/shared';
+export interface OneSliderValueEvent {
+    value: number;
+    originalEvent: Event;
+}
+export interface OneSliderProps {
+    value?: number;
+    defaultValue?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    showValue?: boolean;
+    ariaLabel?: string;
+}
+interface OneSliderState {
+    internalValue: number;
+}
+export declare const ONE_SLIDER_STYLES: OneNamedStyle[];
+export declare function normalizeOneSliderNumber(value: number | undefined, fallback: number): number;
+export declare function clampOneSliderValue(value: number, min: number, max: number): number;
+export declare class OneSlider extends Component<OneSliderProps, OneSliderState> {
+    protected initState(): OneSliderState;
+    protected initStyles(): void;
+    protected render(): VNode;
+    private emitValue;
+}
+export {};

package/dist/slider/index.d.ts

@@ -0,0 +1,2 @@
+export { OneSlider } from './OneSlider';
+export type { OneSliderProps, OneSliderValueEvent } from './OneSlider';

package/dist/styles/shared.d.ts

@@ -9,6 +9,10 @@ export declare const ONE_THEME_DEFAULTS: {
     readonly colorPrimaryHover: "#4bc944";
     readonly colorDanger: "#b83232";
     readonly colorDangerHover: "#9f2d2d";
+    readonly colorInfo: "#2563eb";
+    readonly colorSuccess: "#2f7c39";
+    readonly colorWarning: "#9a6700";
+    readonly colorOverlay: "rgba(22, 32, 24, 0.48)";
     readonly colorSurface: "#ffffff";
     readonly colorText: "#162018";
     readonly colorMuted: "#647268";
@@ -24,7 +28,16 @@ export declare const ONE_THEME_DEFAULTS: {
     readonly fontSizeMd: "14px";
     readonly fontSizeLg: "16px";
     readonly shadowCard: "0 12px 30px rgba(32, 74, 38, 0.1)";
+    readonly shadowOverlay: "0 18px 48px rgba(22, 32, 24, 0.2)";
+    readonly zIndexDialog: "1000";
+    readonly zIndexMessage: "1100";
+    readonly zIndexTooltip: "1200";
     readonly fontFamily: "Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif";
 };
+export declare const ONE_THEME_TYPOGRAPHY_PROPERTIES: Readonly<{
+    fontFamily: "var(--one-font-family, Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif)";
+    lineHeight: "var(--one-line-height, 1.5)";
+}>;
+export declare function oneThemeBorder(color?: string): string;
 export declare function normalizeOneSize(value: unknown): OneComponentSize;
 export declare function oneStylesToSheet(styles: readonly OneNamedStyle[]): StyleSheet;

package/dist/table/OneTable.d.ts

@@ -0,0 +1,26 @@
+import { Component, type VNode } from '@geektech/tsone';
+import { type OneNamedStyle } from '../styles/shared';
+export type OneTableRow = Record<string, unknown>;
+export interface OneTableColumn<T extends OneTableRow = OneTableRow> {
+    key: string;
+    title?: string;
+    render?: (row: T) => VNode | string | number | boolean | null | undefined;
+}
+export interface OneTableProps<T extends OneTableRow = OneTableRow> {
+    data?: readonly T[];
+    columns?: readonly OneTableColumn<T>[];
+    rowKey?: string;
+    striped?: boolean;
+    hover?: boolean;
+    emptyText?: string;
+    ariaLabel?: string;
+}
+export declare const ONE_TABLE_STYLES: OneNamedStyle[];
+export declare class OneTable extends Component<OneTableProps> {
+    protected initState(): object;
+    protected initStyles(): void;
+    protected render(): VNode;
+    private resolveColumns;
+    private renderCell;
+    private normalizeCell;
+}

package/dist/table/index.d.ts

@@ -0,0 +1,2 @@
+export { OneTable } from './OneTable';
+export type { OneTableColumn, OneTableProps, OneTableRow } from './OneTable';

package/dist/tabs/OneTabs.d.ts

@@ -0,0 +1,34 @@
+import { Component, type VNode } from '@geektech/tsone';
+import type { OneNavigationChangeEvent } from '../navigation';
+import { type OneNamedStyle } from '../styles/shared';
+export interface OneTabItem {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+export type OneTabsChangeEvent = OneNavigationChangeEvent<string>;
+export interface OneTabsProps {
+    items: readonly OneTabItem[];
+    value?: string;
+    defaultValue?: string;
+    id?: string;
+    ariaLabel?: string;
+    children?: Array<VNode | string>;
+}
+interface OneTabsState {
+    internalValue: string | undefined;
+}
+export declare const ONE_TABS_STYLES: OneNamedStyle[];
+export declare class OneTabs extends Component<OneTabsProps, OneTabsState> {
+    private readonly idPrefix;
+    protected initState(): OneTabsState;
+    protected initStyles(): void;
+    protected render(): VNode;
+    private normalizedItems;
+    private effectiveValue;
+    private activate;
+    private handleKeydown;
+    private enabledIndices;
+    private focusTab;
+}
+export {};

package/dist/tabs/index.d.ts

@@ -0,0 +1,2 @@
+export { ONE_TABS_STYLES, OneTabs } from './OneTabs';
+export type { OneTabItem, OneTabsChangeEvent, OneTabsProps } from './OneTabs';

package/dist/tag/OneTag.d.ts

@@ -0,0 +1,21 @@
+import { Component, type VNode } from '@geektech/tsone';
+import { type OneDataDisplayVariant } from '../data-display';
+import { type OneNamedStyle } from '../styles/shared';
+import type { OneComponentSize } from '../types';
+export interface OneTagProps {
+    variant?: OneDataDisplayVariant;
+    size?: OneComponentSize;
+    closable?: boolean;
+    children?: Array<VNode | string>;
+}
+interface OneTagState {
+    visible: boolean;
+}
+export declare const ONE_TAG_STYLES: OneNamedStyle[];
+export declare class OneTag extends Component<OneTagProps, OneTagState> {
+    protected initState(): OneTagState;
+    protected initStyles(): void;
+    protected render(): VNode;
+    private close;
+}
+export {};

package/dist/tag/index.d.ts

@@ -0,0 +1,2 @@
+export { OneTag } from './OneTag';
+export type { OneTagProps } from './OneTag';