@platform-blocks/ui 0.1.1

package/lib/components/Title/types.d.ts

@@ -0,0 +1,55 @@
+import type { TextProps } from '../Text';
+/**
+ * Props for the Title component.
+ * Extends TextProps but omits the 'variant' property to provide its own variant system.
+ */
+export interface TitleProps extends Omit<TextProps, 'variant'> {
+    /** The text content to display in the title */
+    text?: string;
+    /** The heading level (1-6), determines the semantic importance and default styling */
+    order?: 1 | 2 | 3 | 4 | 5 | 6;
+    /** Whether to show an underline decoration below the title */
+    underline?: boolean;
+    /** Whether to show a line after the title text */
+    afterline?: boolean;
+    /** Color of the underline decoration */
+    underlineColor?: string;
+    /** Thickness/stroke width of the underline in pixels */
+    underlineStroke?: number;
+    /** Gap between the title text and afterline in pixels */
+    afterlineGap?: number;
+    /** Vertical offset of the underline from the text baseline in pixels */
+    underlineOffset?: number;
+    /** Prefix decoration - can be a boolean to show default prefix or a custom React element */
+    prefix?: boolean | React.ReactNode;
+    /** Style variant for the default prefix decoration */
+    prefixVariant?: 'bar' | 'dot';
+    /** Color of the prefix decoration */
+    prefixColor?: string;
+    /** Size of the prefix decoration in pixels */
+    prefixSize?: number;
+    /** Length of the prefix decoration (for bar variant) in pixels */
+    prefixLength?: number;
+    /** Gap between the prefix and title text in pixels */
+    prefixGap?: number;
+    /** Border radius of the prefix decoration in pixels */
+    prefixRadius?: number;
+    /** Additional styles to apply to the title text element */
+    style?: any;
+    /** Text variant to use, inherits from TextProps variant system */
+    variant?: TextProps['variant'];
+    /** Additional styles to apply to the container wrapping the entire title */
+    containerStyle?: any;
+    /** Icon element to display on the left side of the title */
+    startIcon?: React.ReactNode;
+    /** Icon element to display on the right side of the title */
+    endIcon?: React.ReactNode;
+    /** Action button or element positioned at the far right of the title */
+    action?: React.ReactNode;
+    /** Optional subtitle displayed below the title */
+    subtitle?: React.ReactNode;
+    /** Additional Text props applied to the subtitle when rendered as Text */
+    subtitleProps?: Partial<TextProps>;
+    /** Spacing between the title and subtitle in pixels (default: 8) */
+    subtitleSpacing?: number;
+}

package/lib/components/Toast/Toast.d.ts

@@ -0,0 +1,8 @@
+import { View } from 'react-native';
+import { ToastProps } from './types';
+interface ToastFactoryPayload {
+    props: ToastProps;
+    ref: View;
+}
+export declare const Toast: import("../../core/factory").PlatformBlocksComponent<ToastFactoryPayload>;
+export {};

package/lib/components/Toast/ToastProvider.d.ts

@@ -0,0 +1,88 @@
+import React from 'react';
+import { ToastProps } from './types';
+type ToastRequestListener = () => void;
+export declare function onToastRequested(listener: ToastRequestListener): () => void;
+export type ToastPosition = 'top-left' | 'top-right' | 'top-center' | 'bottom-left' | 'bottom-right' | 'bottom-center';
+export type ToastStackDirection = 'up' | 'down';
+export type ToastQueuePriority = 'fifo' | 'lifo' | 'priority';
+export interface ToastQueueOptions {
+    /** Maximum number of visible toasts per position */
+    maxVisible: number;
+    /** How toasts stack when multiple are shown */
+    stackDirection: ToastStackDirection;
+    /** Space between stacked toasts */
+    spacing: number;
+    /** Queue processing priority */
+    priority: ToastQueuePriority;
+    /** Whether to allow duplicate toasts */
+    allowDuplicates: boolean;
+}
+export interface ToastOptions extends Omit<ToastProps, 'visible' | 'onClose' | 'position'> {
+    /** Unique identifier for the toast */
+    id?: string;
+    /** Position where the toast should appear */
+    position?: ToastPosition;
+    /** Auto hide duration in ms (0 to disable) */
+    autoHide?: number;
+    /** Custom message (alternative to children) */
+    message?: React.ReactNode;
+    /** Priority level for queue management (higher = more important) */
+    priority?: number;
+    /** Group ID for batch operations */
+    groupId?: string;
+}
+interface ToastItem extends ToastOptions {
+    id: string;
+    visible: boolean;
+    position: ToastPosition;
+    timestamp: number;
+    priority: number;
+}
+export interface SeverityToastOptions extends Omit<ToastOptions, 'sev'> {
+}
+export type ToastMessage = string;
+export type ToastShortcut = ToastMessage | SeverityToastOptions;
+interface ToastContextValue {
+    show: (options: ToastOptions) => string;
+    send: (options: ToastOptions) => string;
+    hide: (id: string) => void;
+    hideAll: () => void;
+    hideGroup: (groupId: string) => void;
+    update: (id: string, options: Partial<ToastOptions>) => void;
+    batch: (toasts: ToastOptions[]) => string[];
+    promise: <T>(promise: Promise<T>, options: {
+        pending: ToastShortcut;
+        success: ToastShortcut | ((data: T) => ToastShortcut);
+        error: ToastShortcut | ((error: any) => ToastShortcut);
+    }) => Promise<T>;
+    info: (options: ToastShortcut) => string;
+    success: (options: ToastShortcut) => string;
+    warning: (options: ToastShortcut) => string;
+    warn: (options: ToastShortcut) => string;
+    error: (options: ToastShortcut) => string;
+}
+export declare const useToast: () => ToastContextValue;
+export declare const useActiveToast: () => ToastItem[];
+interface ToastProviderProps {
+    children: React.ReactNode;
+    /** Default position for toasts */
+    defaultPosition?: ToastPosition;
+    /** Maximum number of toasts per position */
+    limit?: number;
+    /** Default auto hide duration */
+    autoHide?: number;
+    /** Queue management options */
+    queueOptions?: Partial<ToastQueueOptions>;
+}
+export declare const ToastProvider: React.FC<ToastProviderProps>;
+export declare const toasts: ToastContextValue;
+export declare const useToastApi: () => ToastContextValue;
+export declare const toast: ToastContextValue;
+export declare const notifications: ToastContextValue;
+export declare const useActiveToasts: () => ToastItem[];
+export declare const onToastsRequested: typeof onToastRequested;
+export declare const onNotificationsRequested: typeof onToastRequested;
+export declare const useNotifications: () => ToastContextValue;
+export declare const useNotificationsApi: () => ToastContextValue;
+export declare const NotificationsProvider: React.FC<ToastProviderProps>;
+export {};

package/lib/components/Toast/index.d.ts

@@ -0,0 +1,3 @@
+export { Toast } from './Toast';
+export type { ToastProps, ToastVariant, ToastColor, ToastSeverity } from './types';
+export { ToastProvider, useToast, useToastApi, useActiveToasts, ToastOptions, ToastPosition, SeverityToastOptions, ToastMessage, ToastShortcut, toast, onToastsRequested } from './ToastProvider';

package/lib/components/Toast/types.d.ts

@@ -0,0 +1,78 @@
+import React from 'react';
+import { ViewStyle } from 'react-native';
+import { SpacingProps } from '../../core/utils';
+import { BorderRadiusProps } from '../../core/theme/radius';
+export type ToastVariant = 'light' | 'filled' | 'outline';
+export type ToastColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'gray';
+export type ToastSeverity = 'info' | 'success' | 'warning' | 'error';
+export type ToastPosition = 'top' | 'bottom' | 'left' | 'right';
+export type ToastAnimationType = 'slide' | 'fade' | 'bounce' | 'scale';
+export interface ToastAction {
+    label: string;
+    onPress: () => void;
+    color?: string;
+}
+export interface ToastAnimationConfig {
+    type?: ToastAnimationType;
+    duration?: number;
+    springConfig?: {
+        damping?: number;
+        stiffness?: number;
+        mass?: number;
+    };
+    easing?: any;
+}
+export interface ToastSwipeConfig {
+    enabled?: boolean;
+    threshold?: number;
+    direction?: 'horizontal' | 'vertical' | 'both';
+    velocityThreshold?: number;
+}
+export interface ToastProps extends SpacingProps, BorderRadiusProps {
+    /** Toast variant */
+    variant?: ToastVariant;
+    /** Toast color - can be theme color or custom color string */
+    color?: ToastColor | string;
+    /** Severity level - provides default styling for common toast types */
+    sev?: ToastSeverity;
+    /** Toast title */
+    title?: string;
+    /** Toast content */
+    children?: React.ReactNode;
+    /** Icon to display */
+    icon?: React.ReactNode;
+    /** Whether to show close button */
+    withCloseButton?: boolean;
+    /** Whether to show loading indicator */
+    loading?: boolean;
+    /** Close button accessibility label */
+    closeButtonLabel?: string;
+    /** Callback when close button is pressed */
+    onClose?: () => void;
+    /** Whether the toast is visible */
+    visible?: boolean;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Auto hide duration in ms (0 to disable) */
+    autoHide?: number;
+    /** Position of the toast for animation direction */
+    position?: ToastPosition;
+    /** Container style */
+    style?: ViewStyle;
+    /** Test ID for testing */
+    testID?: string;
+    /** Action buttons */
+    actions?: ToastAction[];
+    /** Whether toast can be dismissed by tapping */
+    dismissOnTap?: boolean;
+    /** Maximum width for toast */
+    maxWidth?: number;
+    /** Persist toast until manually dismissed */
+    persistent?: boolean;
+    /** Animation configuration */
+    animationConfig?: ToastAnimationConfig;
+    /** Swipe to dismiss configuration */
+    swipeConfig?: ToastSwipeConfig;
+    /** Callback when toast is dismissed via swipe */
+    onSwipeDismiss?: () => void;
+}

package/lib/components/Toggle/Toggle.d.ts

@@ -0,0 +1,10 @@
+import { View } from 'react-native';
+import { ToggleButtonProps, ToggleGroupProps } from './types';
+export declare const ToggleButton: import("../../core/factory").PlatformBlocksComponent<{
+    props: ToggleButtonProps;
+    ref: View;
+}>;
+export declare const ToggleGroup: import("../../core/factory").PlatformBlocksComponent<{
+    props: ToggleGroupProps;
+    ref: View;
+}>;

package/lib/components/Toggle/ToggleBar.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import type { SizeValue } from '../../core/theme/sizes';
+export interface ToggleBarOption {
+    /** Display label for the option */
+    label: string;
+    /** Value for the option */
+    value: string | number;
+    /** Optional left icon */
+    startIcon?: React.ReactNode;
+    /** Optional right icon */
+    endIcon?: React.ReactNode;
+    /** Color for the chip when selected */
+    color?: string;
+    /** Override default chip variant */
+    chipVariant?: 'filled' | 'outline' | 'light';
+    /** Disable this option */
+    disabled?: boolean;
+}
+export interface ToggleBarProps {
+    /** Selected values */
+    value: (string | number)[];
+    /** Called with updated values */
+    onChange?: (vals: (string | number)[]) => void;
+    /** Options to render */
+    options: ToggleBarOption[];
+    /** Allow multiple selection. If false acts like exclusive */
+    multiple?: boolean;
+    /** Require at least one selection */
+    required?: boolean;
+    /** Overall size passed to chips */
+    size?: SizeValue;
+    /** Default chip variant when not selected */
+    chipVariant?: 'filled' | 'outline' | 'light';
+    /** Variant to use when selected (defaults to 'filled') */
+    selectedVariant?: 'filled' | 'outline' | 'light';
+    /** Gap between chips */
+    gap?: number;
+    /** Row wrapping container style */
+    style?: any;
+}
+export declare const ToggleBar: React.FC<ToggleBarProps>;
+export default ToggleBar;

package/lib/components/Toggle/index.d.ts

@@ -0,0 +1,4 @@
+export { ToggleButton, ToggleGroup } from './Toggle';
+export { ToggleBar } from './ToggleBar';
+export type { ToggleButtonProps, ToggleGroupProps, ToggleGroupContextValue } from './types';
+export type { ToggleBarProps, ToggleBarOption } from './ToggleBar';

package/lib/components/Toggle/types.d.ts

@@ -0,0 +1,68 @@
+import { SpacingProps, LayoutProps } from '../../core/utils';
+import { BorderRadiusProps } from '../../core/theme/radius';
+import { SizeValue } from '../../core/theme/sizes';
+export interface ToggleButtonProps extends SpacingProps, LayoutProps, BorderRadiusProps {
+    /** Value for this toggle button */
+    value: string | number;
+    /** Whether this button is selected */
+    selected?: boolean;
+    /** Callback when button is pressed */
+    onPress?: (value: string | number) => void;
+    /** Whether the button is disabled */
+    disabled?: boolean;
+    /** Button content */
+    children: React.ReactNode;
+    /** Size of the toggle button */
+    size?: SizeValue;
+    /** Color variant */
+    color?: string;
+    /** Named color variant from theme */
+    colorVariant?: 'primary' | 'secondary' | 'success' | 'error' | 'warning';
+    /** Visual style variant */
+    variant?: 'solid' | 'ghost';
+    /** Custom styles */
+    style?: any;
+    /** Test ID for testing */
+    testID?: string;
+}
+export interface ToggleGroupProps extends SpacingProps, LayoutProps, BorderRadiusProps {
+    /** Current selected value(s) */
+    value?: string | number | (string | number)[];
+    /** Initial value(s) for uncontrolled usage */
+    defaultValue?: string | number | (string | number)[];
+    /** Callback when selection changes */
+    onChange?: (value: string | number | (string | number)[]) => void;
+    /** Whether only one option can be selected at a time */
+    exclusive?: boolean;
+    /** Whether the group is disabled */
+    disabled?: boolean;
+    /** Size of all toggle buttons */
+    size?: SizeValue;
+    /** Color variant for all buttons */
+    color?: string;
+    /** Named color variant from theme for all buttons */
+    colorVariant?: 'primary' | 'secondary' | 'success' | 'error' | 'warning';
+    /** Visual style variant for all buttons */
+    variant?: 'solid' | 'ghost';
+    /** Orientation of the toggle group */
+    orientation?: 'horizontal' | 'vertical';
+    /** Whether selection is required (at least one must be selected) */
+    required?: boolean;
+    /** Custom styles */
+    style?: any;
+    /** Toggle buttons */
+    children: React.ReactNode;
+    /** Test ID for testing */
+    testID?: string;
+}
+export interface ToggleGroupContextValue {
+    value?: string | number | (string | number)[];
+    onChange?: (value: string | number) => void;
+    exclusive?: boolean;
+    disabled?: boolean;
+    size?: SizeValue;
+    color?: string;
+    colorVariant?: 'primary' | 'secondary' | 'success' | 'error' | 'warning';
+    variant?: 'solid' | 'ghost';
+    required?: boolean;
+}

package/lib/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,2 @@
+import { TooltipFactoryPayload } from './types';
+export declare const Tooltip: import("../../core/factory").PlatformBlocksComponent<TooltipFactoryPayload>;

package/lib/components/Tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { Tooltip } from './Tooltip';
+export type { TooltipProps, TooltipPositionType } from './types';

package/lib/components/Tooltip/types.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import { ViewStyle, View } from 'react-native';
+import { SizeValue } from '../../core/theme/sizes';
+export type TooltipPositionType = 'top' | 'bottom' | 'left' | 'right';
+export interface TooltipProps {
+    /** Tooltip label */
+    label: string;
+    /** Position of the tooltip */
+    position?: TooltipPositionType;
+    /** Whether to show an arrow */
+    withArrow?: boolean;
+    /** Tooltip color */
+    color?: string;
+    /** Border radius */
+    radius?: SizeValue;
+    /** Offset from target */
+    offset?: number;
+    /** Whether tooltip is multiline */
+    multiline?: boolean;
+    /** Width for multiline tooltip */
+    width?: number;
+    /** Whether tooltip is controlled */
+    opened?: boolean;
+    /** Open delay in ms */
+    openDelay?: number;
+    /** Close delay in ms */
+    closeDelay?: number;
+    /** Events that trigger tooltip */
+    events?: {
+        hover?: boolean;
+        focus?: boolean;
+        touch?: boolean;
+    };
+    /** Children element to attach tooltip to */
+    children: React.ReactElement;
+    /** Container style */
+    style?: ViewStyle;
+    /** Test ID for testing */
+    testID?: string;
+}
+export interface TooltipFactoryPayload {
+    props: TooltipProps;
+    ref: View;
+}

package/lib/components/Tree/Tree.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { TreeProps } from './types';
+export type { TreeNode, TreeProps } from './types';
+export declare const Tree: React.FC<TreeProps>;
+export default Tree;

package/lib/components/Tree/index.d.ts

@@ -0,0 +1,2 @@
+export { Tree } from './Tree';
+export type { TreeProps, TreeNode } from './types';

package/lib/components/Tree/types.d.ts

@@ -0,0 +1,65 @@
+export interface TreeNode {
+    id: string;
+    label: string;
+    children?: TreeNode[];
+    href?: string;
+    startOpen?: boolean;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    selectable?: boolean;
+    data?: any;
+}
+export interface TreeProps {
+    data: TreeNode[];
+    /** Called when a leaf (no children) or any node with href is pressed */
+    onNavigate?: (node: TreeNode) => void;
+    /** Allow collapsing/expanding */
+    collapsible?: boolean;
+    /** Indent size in px for each depth level */
+    indent?: number;
+    /** Render only expanded branches (otherwise all flat) */
+    accordion?: boolean;
+    /** Initially expand all nodes */
+    expandAll?: boolean;
+    /** Custom render for label */
+    renderLabel?: (node: TreeNode, depth: number, isOpen: boolean, state: {
+        selected: boolean;
+        checked: boolean;
+        indeterminate: boolean;
+    }) => React.ReactNode;
+    style?: any;
+    /** Selection mode */
+    selectionMode?: 'none' | 'single' | 'multiple';
+    /** Controlled selected ids */
+    selectedIds?: string[];
+    /** Uncontrolled default selected ids */
+    defaultSelectedIds?: string[];
+    /** Selection change callback */
+    onSelectionChange?: (ids: string[], node: TreeNode) => void;
+    /** Fired after selection changes with the node considered primary (first in selection) */
+    onActiveNodeChange?: (node: TreeNode | null, ids: string[]) => void;
+    /** Enable checkboxes */
+    checkboxes?: boolean;
+    /** Controlled checked ids */
+    checkedIds?: string[];
+    /** Uncontrolled default checked ids */
+    defaultCheckedIds?: string[];
+    /** Checked change callback */
+    onCheckedChange?: (ids: string[], node: TreeNode) => void;
+    /** Cascade checking to descendants */
+    cascadeCheck?: boolean;
+    /** Expand branches also when pressing label area (not just chevron) */
+    expandOnClick?: boolean;
+    /** Controlled external expansion state */
+    expandedIds?: string[];
+    /** Expansion change callback */
+    onToggle?: (node: TreeNode, expanded: boolean) => void;
+    /** Filter query to highlight / hide unmatched nodes */
+    filterQuery?: string;
+    /** If true, nodes that don't match filter are hidden; otherwise all shown with highlight */
+    hideFiltered?: boolean;
+    /** Content when no results after filtering */
+    noResultsFallback?: React.ReactNode;
+    /** Custom highlight function for labels (return ReactNode) */
+    highlight?: (label: string, query: string) => React.ReactNode;
+}

package/lib/components/Video/NativeVideoPlayer.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import { ImageStyle } from 'react-native';
+import type { VideoSource, VideoPlaybackRate } from './types';
+interface NativeVideoPlayerProps {
+    source: VideoSource;
+    poster?: string;
+    autoPlay?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+    volume?: number;
+    playbackRate?: VideoPlaybackRate;
+    onPlay?: () => void;
+    onPause?: () => void;
+    onTimeUpdate?: (time: number) => void;
+    onDurationChange?: (duration: number) => void;
+    onError?: (error: string) => void;
+    onLoad?: () => void;
+    onLoadStart?: () => void;
+    onBuffer?: (buffering: boolean) => void;
+    style?: ImageStyle;
+    accessibilityLabel?: string;
+}
+interface NativeVideoPlayerRef {
+    play: () => void;
+    pause: () => void;
+    seek: (time: number) => void;
+    setVolume: (volume: number) => void;
+    setPlaybackRate: (rate: VideoPlaybackRate) => void;
+    toggleFullscreen: () => void;
+    getVideoElement: () => HTMLVideoElement | null;
+}
+export declare const NativeVideoPlayer: React.ForwardRefExoticComponent<NativeVideoPlayerProps & React.RefAttributes<NativeVideoPlayerRef>>;
+export {};

package/lib/components/Video/Video.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { VideoProps, VideoRef } from './types';
+export declare const Video: React.ForwardRefExoticComponent<VideoProps & React.RefAttributes<VideoRef>>;

package/lib/components/Video/VideoControls.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { ViewStyle } from 'react-native';
+import type { VideoControls as VideoControlsConfig, VideoState, VideoPlaybackRate } from './types';
+interface VideoControlsProps {
+    config: VideoControlsConfig;
+    state: VideoState;
+    onPlay: () => void;
+    onPause: () => void;
+    onSeek: (time: number) => void;
+    onVolumeChange: (volume: number) => void;
+    onPlaybackRateChange: (rate: VideoPlaybackRate) => void;
+    onToggleFullscreen: () => void;
+    onScrubbingChange?: (isScrubbing: boolean) => void;
+    style?: ViewStyle;
+}
+export declare function VideoControls({ config, state, onPlay, onPause, onSeek, onVolumeChange, onPlaybackRateChange, onToggleFullscreen, onScrubbingChange, style }: VideoControlsProps): React.JSX.Element;
+export {};

package/lib/components/Video/VideoTimeline.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { ViewStyle } from 'react-native';
+import type { VideoTimelineEvent } from './types';
+interface VideoTimelineProps {
+    timeline: VideoTimelineEvent[];
+    duration: number;
+    currentTime: number;
+    onSeek: (time: number) => void;
+    style?: ViewStyle;
+}
+export declare function VideoTimeline({ timeline, duration, currentTime, onSeek, style }: VideoTimelineProps): React.JSX.Element | null;
+export {};

package/lib/components/Video/YouTubePlayer.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import { ImageStyle } from 'react-native';
+import type { VideoSource, VideoPlaybackRate, VideoQuality } from './types';
+interface YouTubePlayerProps {
+    source: VideoSource;
+    poster?: string;
+    autoPlay?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+    volume?: number;
+    playbackRate?: VideoPlaybackRate;
+    quality?: VideoQuality;
+    youtubeOptions?: {
+        start?: number;
+        end?: number;
+        modestbranding?: boolean;
+        rel?: boolean;
+        iv_load_policy?: number;
+    };
+    onPlay?: () => void;
+    onPause?: () => void;
+    onTimeUpdate?: (time: number) => void;
+    onDurationChange?: (duration: number) => void;
+    onVolumeChange?: (volume: number) => void;
+    onMute?: () => void;
+    onUnmute?: () => void;
+    onError?: (error: string) => void;
+    onLoad?: () => void;
+    onLoadStart?: () => void;
+    onBuffer?: (buffering: boolean) => void;
+    style?: ImageStyle;
+    accessibilityLabel?: string;
+}
+interface YouTubePlayerRef {
+    play: () => void;
+    pause: () => void;
+    seek: (time: number) => void;
+    setVolume: (volume: number) => void;
+    setPlaybackRate: (rate: VideoPlaybackRate) => void;
+    toggleFullscreen: () => void;
+    getVideoElement: () => HTMLVideoElement | null;
+}
+export declare const YouTubePlayer: React.ForwardRefExoticComponent<YouTubePlayerProps & React.RefAttributes<YouTubePlayerRef>>;
+export {};

package/lib/components/Video/index.d.ts

@@ -0,0 +1,2 @@
+export { Video } from './Video';
+export type { VideoProps, VideoRef, VideoSource, VideoState, VideoControls, VideoTimelineEvent, VideoQuality, VideoPlaybackRate } from './types';