orizon 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Orizon Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# Orizon
+
+Ant Design API on shadcn/ui primitives. 68 React components with full TypeScript support.
+
+## Install
+
+```bash
+npm install orizon
+```
+
+**Peer dependencies** — your project needs:
+
+```bash
+npm install react react-dom tailwindcss
+```
+
+For the **Form** component (optional):
+
+```bash
+npm install react-hook-form @hookform/resolvers zod
+```
+
+## Setup
+
+Add these 3 lines to your app's CSS file:
+
+```css
+@import "tailwindcss";
+@import "orizon/preset.css";
+@source "../node_modules/orizon/dist";
+```
+
+That's it. The `@source` directive tells Tailwind to scan Orizon's compiled JS for utility classes.
+
+## Usage
+
+```tsx
+import { Button, Input, Form, Table, Modal, message } from "orizon";
+
+function App() {
+  return (
+    <div>
+      <Button type="primary" onClick={() => message.success("Hello!")}>
+        Click me
+      </Button>
+    </div>
+  );
+}
+```
+
+The API follows Ant Design exactly — same props, same patterns:
+
+```tsx
+// Compound components
+<Input.Password placeholder="Password" />
+<Form.Item label="Name" name="name">
+  <Input />
+</Form.Item>
+
+// Static methods
+Modal.confirm({ title: "Sure?", onOk: () => {} });
+message.success("Saved!");
+notification.open({ message: "Done" });
+```
+
+## Components (68)
+
+| Category | Components |
+|----------|-----------|
+| General | Button, FloatButton, Typography |
+| Layout | Space, Flex, Grid, Divider, Layout, Masonry, Splitter |
+| Navigation | Anchor, Breadcrumb, Dropdown, Menu, Pagination, Steps, Tabs |
+| Data Entry | AutoComplete, Cascader, Checkbox, ColorPicker, DatePicker, Form, Input, InputNumber, Mentions, Radio, Rate, Select, Slider, Switch, TimePicker, Transfer, TreeSelect, Upload |
+| Data Display | Avatar, Badge, Calendar, Card, Carousel, Collapse, Descriptions, Empty, Image, List, Popover, QRCode, Segmented, Statistic, Table, Tag, Timeline, Tooltip, Tour, Tree |
+| Feedback | Alert, Drawer, Message, Modal, Notification, Popconfirm, Progress, Result, Skeleton, Spin, Watermark |
+| Other | Affix, App, ConfigProvider |
+
+## Theming
+
+Override CSS variables in your CSS:
+
+```css
+:root {
+  --primary: oklch(0.6 0.25 150);    /* green primary */
+  --radius: 0.5rem;                   /* rounder corners */
+}
+```
+
+Or use the ConfigProvider:
+
+```tsx
+import { ConfigProvider } from "orizon";
+
+<ConfigProvider theme={{ algorithm: "dark" }}>
+  <App />
+</ConfigProvider>
+```
+
+## License
+
+MIT

package/dist/components/affix/Affix.d.ts

@@ -0,0 +1,4 @@
+import { AffixProps } from './types';
+import * as React from "react";
+declare const Affix: React.FC<AffixProps>;
+export { Affix };

package/dist/components/affix/index.d.ts

@@ -0,0 +1,2 @@
+export { Affix } from './Affix';
+export type { AffixProps } from './types';

package/dist/components/affix/types.d.ts

@@ -0,0 +1,10 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface AffixProps {
+    offsetTop?: number;
+    offsetBottom?: number;
+    target?: () => HTMLElement | Window;
+    onChange?: (affixed: boolean) => void;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}

package/dist/components/alert/Alert.d.ts

@@ -0,0 +1,4 @@
+import { AlertProps } from './types';
+import * as React from "react";
+declare const InternalAlert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+export { InternalAlert };

package/dist/components/alert/ErrorBoundary.d.ts

@@ -0,0 +1,12 @@
+import { AlertErrorBoundaryProps } from './types';
+import * as React from "react";
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+declare class AlertErrorBoundary extends React.Component<AlertErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: AlertErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    render(): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+}
+export { AlertErrorBoundary };

package/dist/components/alert/index.d.ts

@@ -0,0 +1,8 @@
+import { InternalAlert } from './Alert';
+import { AlertErrorBoundary } from './ErrorBoundary';
+type AlertComponent = typeof InternalAlert & {
+    ErrorBoundary: typeof AlertErrorBoundary;
+};
+declare const Alert: AlertComponent;
+export { Alert };
+export type { AlertProps, AlertType, AlertClosableConfig, AlertErrorBoundaryProps, } from './types';

package/dist/components/alert/types.d.ts

@@ -0,0 +1,45 @@
+import { ReactNode } from 'react';
+export type AlertType = "success" | "info" | "warning" | "error";
+export interface AlertClosableConfig {
+    closeIcon?: ReactNode;
+    afterClose?: () => void;
+    onClose?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+}
+export interface AlertProps {
+    /** Alert type */
+    type?: AlertType;
+    /** Alert title / message */
+    message?: ReactNode;
+    /** Alias for message */
+    title?: ReactNode;
+    /** Additional description below the title */
+    description?: ReactNode;
+    /** Whether alert can be closed */
+    closable?: boolean | AlertClosableConfig;
+    /** Show type icon */
+    showIcon?: boolean;
+    /** Custom icon */
+    icon?: ReactNode;
+    /** Action area on the right */
+    action?: ReactNode;
+    /** Banner mode (no border, full width) */
+    banner?: boolean;
+    /** Called after close animation finishes */
+    afterClose?: () => void;
+    /** Custom close icon */
+    closeIcon?: ReactNode;
+    /** Called when close button is clicked */
+    onClose?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Extra class name */
+    className?: string;
+    /** Inline style */
+    style?: React.CSSProperties;
+}
+export interface AlertErrorBoundaryProps {
+    /** Title shown in the error alert */
+    message?: ReactNode;
+    /** Description shown in the error alert */
+    description?: ReactNode;
+    /** Children to wrap */
+    children?: ReactNode;
+}

package/dist/components/anchor/Anchor.d.ts

@@ -0,0 +1,4 @@
+import { AnchorProps } from './types';
+import * as React from "react";
+declare const Anchor: React.ForwardRefExoticComponent<AnchorProps & React.RefAttributes<HTMLDivElement>>;
+export { Anchor };

package/dist/components/anchor/index.d.ts

@@ -0,0 +1,2 @@
+export { Anchor } from './Anchor';
+export type { AnchorProps, AnchorItem, AnchorDirection } from './types';

package/dist/components/anchor/types.d.ts

@@ -0,0 +1,47 @@
+import { ReactNode, CSSProperties } from 'react';
+export type AnchorDirection = "horizontal" | "vertical";
+export interface AnchorItem {
+    /** Unique key for the anchor */
+    key: string;
+    /** Link href (e.g., "#section-id") */
+    href: string;
+    /** Display title */
+    title: ReactNode;
+    /** Nested children anchor items */
+    children?: AnchorItem[];
+    /** Target for the link (e.g., "_blank") */
+    target?: string;
+    /** Class name for the item */
+    className?: string;
+}
+export interface AnchorProps {
+    /** Anchor items */
+    items?: AnchorItem[];
+    /** Direction of the anchor layout */
+    direction?: AnchorDirection;
+    /** Custom function to determine the current active anchor */
+    getCurrentAnchor?: (activeLink: string) => string;
+    /** Pixel offset from top when scrolling to an anchor */
+    targetOffset?: number;
+    /** Whether to pin the anchor to the viewport (affix mode) */
+    affix?: boolean;
+    /** Offset top when affix is active */
+    offsetTop?: number;
+    /** Callback when active anchor changes */
+    onChange?: (currentActiveLink: string) => void;
+    /** Callback when an anchor link is clicked */
+    onClick?: (e: React.MouseEvent, link: {
+        title: ReactNode;
+        href: string;
+    }) => void;
+    /** Bounds for activating anchor links (proportion of viewport) */
+    bounds?: number;
+    /** Replace browser history instead of push */
+    replace?: boolean;
+    /** Container to listen for scroll events (defaults to window) */
+    getContainer?: () => HTMLElement | Window;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+}

package/dist/components/app/App.d.ts

@@ -0,0 +1,13 @@
+import { MessageAPI } from '../message/types';
+import { NotificationAPI } from '../notification/types';
+import { ModalHookAPI } from '../modal/types';
+import { AppProps } from './types';
+import * as React from "react";
+interface AppContextValue {
+    message: MessageAPI;
+    notification: NotificationAPI;
+    modal: ModalHookAPI;
+}
+declare function useApp(): AppContextValue;
+declare const InternalApp: React.FC<AppProps>;
+export { InternalApp, useApp };

package/dist/components/app/index.d.ts

@@ -0,0 +1,7 @@
+import { InternalApp, useApp } from './App';
+type AppComponent = typeof InternalApp & {
+    useApp: typeof useApp;
+};
+declare const App: AppComponent;
+export { App };
+export type { AppProps } from './types';

package/dist/components/app/types.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode, CSSProperties } from 'react';
+export interface AppProps {
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    component?: keyof React.JSX.IntrinsicElements | false;
+    message?: Record<string, unknown>;
+    notification?: Record<string, unknown>;
+}

package/dist/components/auto-complete/AutoComplete.d.ts

@@ -0,0 +1,4 @@
+import { AutoCompleteProps } from './types';
+import * as React from "react";
+declare const InternalAutoComplete: React.ForwardRefExoticComponent<AutoCompleteProps & React.RefAttributes<HTMLDivElement>>;
+export { InternalAutoComplete };

package/dist/components/auto-complete/index.d.ts

@@ -0,0 +1,3 @@
+declare const AutoComplete: import('react').ForwardRefExoticComponent<import('./types').AutoCompleteProps & import('react').RefAttributes<HTMLDivElement>>;
+export { AutoComplete };
+export type { AutoCompleteProps, AutoCompleteOption, AutoCompleteSize, AutoCompleteStatus, AutoCompleteVariant, } from './types';

package/dist/components/auto-complete/types.d.ts

@@ -0,0 +1,36 @@
+import { CSSProperties, ReactNode } from 'react';
+export type AutoCompleteSize = "small" | "middle" | "large";
+export type AutoCompleteStatus = "error" | "warning";
+export type AutoCompleteVariant = "outlined" | "borderless" | "filled";
+export interface AutoCompleteOption {
+    value: string;
+    label?: ReactNode;
+    disabled?: boolean;
+}
+export interface AutoCompleteProps {
+    options?: AutoCompleteOption[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onSelect?: (value: string, option: AutoCompleteOption) => void;
+    onSearch?: (value: string) => void;
+    onClear?: () => void;
+    allowClear?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onDropdownVisibleChange?: (open: boolean) => void;
+    filterOption?: boolean | ((inputValue: string, option: AutoCompleteOption) => boolean);
+    defaultActiveFirstOption?: boolean;
+    backfill?: boolean;
+    size?: AutoCompleteSize;
+    status?: AutoCompleteStatus;
+    variant?: AutoCompleteVariant;
+    notFoundContent?: ReactNode;
+    popupClassName?: string;
+    popupMatchSelectWidth?: boolean | number;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}

package/dist/components/avatar/Avatar.d.ts

@@ -0,0 +1,5 @@
+import { AvatarProps, AvatarGroupProps } from './types';
+import * as React from "react";
+declare const InternalAvatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+declare const InternalAvatarGroup: React.FC<AvatarGroupProps>;
+export { InternalAvatar, InternalAvatarGroup };

package/dist/components/avatar/index.d.ts

@@ -0,0 +1,7 @@
+import { InternalAvatar, InternalAvatarGroup } from './Avatar';
+type AvatarComponent = typeof InternalAvatar & {
+    Group: typeof InternalAvatarGroup;
+};
+declare const Avatar: AvatarComponent;
+export { Avatar };
+export type { AvatarProps, AvatarGroupProps, AvatarSize, AvatarShape, AvatarGroupMaxConfig } from './types';

package/dist/components/avatar/types.d.ts

@@ -0,0 +1,49 @@
+import { ReactNode, CSSProperties, HTMLAttributes } from 'react';
+export type AvatarSize = number | "small" | "middle" | "large";
+export type AvatarShape = "circle" | "square";
+export interface AvatarProps extends Omit<HTMLAttributes<HTMLSpanElement>, "children"> {
+    /** Image source */
+    src?: string;
+    /** Size of avatar */
+    size?: AvatarSize;
+    /** Shape */
+    shape?: AvatarShape;
+    /** Icon displayed when no src */
+    icon?: ReactNode;
+    /** Alt text for image */
+    alt?: string;
+    /** Gap between character and border */
+    gap?: number;
+    /** Src set */
+    srcSet?: string;
+    /** Whether to allow drag */
+    draggable?: boolean;
+    /** Cross-origin */
+    crossOrigin?: "" | "anonymous" | "use-credentials";
+    /** Fallback text (children) */
+    children?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    /** onError callback for image loading */
+    onError?: () => boolean;
+}
+export interface AvatarGroupMaxConfig {
+    count?: number;
+    style?: CSSProperties;
+    popover?: boolean;
+}
+export interface AvatarGroupProps {
+    /** Max config */
+    max?: AvatarGroupMaxConfig;
+    /** Default size for all avatars */
+    size?: AvatarSize;
+    /** Default shape for all avatars */
+    shape?: AvatarShape;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    children?: ReactNode;
+}

package/dist/components/badge/Badge.d.ts

@@ -0,0 +1,5 @@
+import { BadgeProps, BadgeRibbonProps } from './types';
+import * as React from "react";
+declare const InternalBadge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLSpanElement>>;
+declare const BadgeRibbon: React.FC<BadgeRibbonProps>;
+export { InternalBadge, BadgeRibbon };

package/dist/components/badge/index.d.ts

@@ -0,0 +1,7 @@
+import { InternalBadge, BadgeRibbon } from './Badge';
+type BadgeComponent = typeof InternalBadge & {
+    Ribbon: typeof BadgeRibbon;
+};
+declare const Badge: BadgeComponent;
+export { Badge };
+export type { BadgeProps, BadgeRibbonProps, BadgeStatus, BadgeSize, PresetColor, RibbonPlacement, } from './types';

package/dist/components/badge/types.d.ts

@@ -0,0 +1,45 @@
+import { ReactNode, CSSProperties, HTMLAttributes } from 'react';
+export type BadgeStatus = "success" | "processing" | "default" | "error" | "warning";
+export type BadgeSize = "default" | "small";
+export type PresetColor = "blue" | "purple" | "cyan" | "green" | "magenta" | "pink" | "red" | "orange" | "yellow" | "volcano" | "geekblue" | "lime" | "gold";
+export interface BadgeProps extends Omit<HTMLAttributes<HTMLSpanElement>, "title"> {
+    /** Number to display */
+    count?: ReactNode;
+    /** Show as a dot */
+    dot?: boolean;
+    /** Status type */
+    status?: BadgeStatus;
+    /** Custom color */
+    color?: PresetColor | string;
+    /** Size */
+    size?: BadgeSize;
+    /** Whether to show when count is 0 */
+    showZero?: boolean;
+    /** Max count to show */
+    overflowCount?: number;
+    /** Position offset [x, y] */
+    offset?: [number, number];
+    /** Title attribute for the badge */
+    title?: string;
+    /** Text to display next to status dot */
+    text?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+export type RibbonPlacement = "start" | "end";
+export interface BadgeRibbonProps {
+    /** Ribbon text */
+    text?: ReactNode;
+    /** Ribbon color */
+    color?: PresetColor | string;
+    /** Placement */
+    placement?: RibbonPlacement;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    children?: ReactNode;
+}

package/dist/components/breadcrumb/Breadcrumb.d.ts

@@ -0,0 +1,4 @@
+import { BreadcrumbProps } from './types';
+import * as React from "react";
+declare const Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLElement>>;
+export { Breadcrumb };

package/dist/components/breadcrumb/index.d.ts

@@ -0,0 +1,2 @@
+export { Breadcrumb } from './Breadcrumb';
+export type { BreadcrumbProps, BreadcrumbItemType, BreadcrumbMenuItemType } from './types';

package/dist/components/breadcrumb/types.d.ts

@@ -0,0 +1,35 @@
+import { ReactNode, MouseEventHandler } from 'react';
+export interface BreadcrumbMenuItemType {
+    /** Key for the menu item */
+    key: string;
+    /** Label text */
+    label: ReactNode;
+    /** Optional href */
+    href?: string;
+    /** Click handler */
+    onClick?: MouseEventHandler;
+}
+export interface BreadcrumbItemType {
+    /** Title text or node */
+    title: ReactNode;
+    /** Link href */
+    href?: string;
+    /** Dropdown menu for this item */
+    menu?: {
+        items: BreadcrumbMenuItemType[];
+    };
+    /** Click handler */
+    onClick?: MouseEventHandler;
+    /** Path key (for routing) */
+    path?: string;
+    /** Class name for the item */
+    className?: string;
+}
+export interface BreadcrumbProps {
+    /** Breadcrumb items */
+    items?: BreadcrumbItemType[];
+    /** Custom separator, defaults to "/" */
+    separator?: ReactNode;
+    /** Extra class name */
+    className?: string;
+}

package/dist/components/button/Button.d.ts

@@ -0,0 +1,4 @@
+import { ButtonProps } from './types';
+import * as React from "react";
+declare const InternalButton: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { InternalButton };

package/dist/components/button/ButtonGroup.d.ts

@@ -0,0 +1,4 @@
+import { ButtonGroupProps } from './types';
+import * as React from "react";
+declare const ButtonGroup: React.FC<ButtonGroupProps>;
+export { ButtonGroup };

package/dist/components/button/index.d.ts

@@ -0,0 +1,8 @@
+import { InternalButton } from './Button';
+import { ButtonGroup } from './ButtonGroup';
+type ButtonComponent = typeof InternalButton & {
+    Group: typeof ButtonGroup;
+};
+declare const Button: ButtonComponent;
+export { Button };
+export type { ButtonProps, ButtonGroupProps, ButtonType, ButtonSize, ButtonShape, ButtonHTMLType } from './types';

package/dist/components/button/types.d.ts

@@ -0,0 +1,35 @@
+import { ReactNode, MouseEventHandler, ButtonHTMLAttributes } from 'react';
+export type ButtonType = "primary" | "default" | "dashed" | "link" | "text";
+export type ButtonSize = "small" | "middle" | "large";
+export type ButtonShape = "default" | "circle" | "round";
+export type ButtonHTMLType = "button" | "submit" | "reset";
+export interface ButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "type"> {
+    /** Antd button type */
+    type?: ButtonType;
+    /** Size of button */
+    size?: ButtonSize;
+    /** Shape of button */
+    shape?: ButtonShape;
+    /** Show loading spinner */
+    loading?: boolean;
+    /** Danger styling */
+    danger?: boolean;
+    /** Ghost styling (transparent background) */
+    ghost?: boolean;
+    /** Full width */
+    block?: boolean;
+    /** Icon placed before children */
+    icon?: ReactNode;
+    /** Icon placement */
+    iconPosition?: "start" | "end";
+    /** HTML button type attribute */
+    htmlType?: ButtonHTMLType;
+    /** Click handler */
+    onClick?: MouseEventHandler<HTMLButtonElement>;
+    children?: ReactNode;
+}
+export interface ButtonGroupProps {
+    size?: ButtonSize;
+    className?: string;
+    children?: ReactNode;
+}

package/dist/components/calendar/Calendar.d.ts

@@ -0,0 +1,4 @@
+import { CalendarProps } from './types';
+import * as React from "react";
+declare const InternalCalendar: React.FC<CalendarProps>;
+export { InternalCalendar };

package/dist/components/calendar/index.d.ts

@@ -0,0 +1,3 @@
+declare const Calendar: import('react').FC<import('./types').CalendarProps>;
+export { Calendar };
+export type { CalendarProps, CalendarMode } from './types';

package/dist/components/calendar/types.d.ts

@@ -0,0 +1,45 @@
+import { ReactNode, CSSProperties } from 'react';
+export type CalendarMode = "month" | "year";
+export interface CalendarProps {
+    /** Selected date value (controlled) */
+    value?: Date;
+    /** Default selected date */
+    defaultValue?: Date;
+    /** Calendar mode */
+    mode?: CalendarMode;
+    /** Whether to render full-screen calendar */
+    fullscreen?: boolean;
+    /** Custom cell render */
+    cellRender?: (date: Date, info: {
+        originNode: ReactNode;
+        type: "date" | "month";
+    }) => ReactNode;
+    /** Custom header render */
+    headerRender?: (config: {
+        value: Date;
+        type: CalendarMode;
+        onChange: (date: Date) => void;
+        onTypeChange: (type: CalendarMode) => void;
+    }) => ReactNode;
+    /** Whether date is disabled */
+    disabledDate?: (date: Date) => boolean;
+    /** Callback when date changes */
+    onChange?: (date: Date) => void;
+    /** Callback when panel mode changes */
+    onPanelChange?: (date: Date, mode: CalendarMode) => void;
+    /** Callback when date is selected */
+    onSelect?: (date: Date, info: {
+        source: "year" | "month" | "date";
+    }) => void;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    /** Locale */
+    locale?: {
+        lang?: {
+            locale?: string;
+            monthFormat?: string;
+        };
+    };
+}

package/dist/components/card/Card.d.ts

@@ -0,0 +1,6 @@
+import { CardProps, CardMetaProps, CardGridProps } from './types';
+import * as React from "react";
+declare const CardMeta: React.FC<CardMetaProps>;
+declare const CardGrid: React.FC<CardGridProps>;
+declare const InternalCard: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+export { InternalCard, CardMeta, CardGrid };