@platform-blocks/ui 0.1.1

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

@@ -0,0 +1,232 @@
+import type { WaveformProps } from '../Waveform/types';
+export interface AudioPlayerProps extends Omit<WaveformProps, 'peaks' | 'progress' | 'variant'> {
+    /** Audio source - can be URL, local file, or asset */
+    source?: string | number | {
+        uri: string;
+    };
+    /** Pre-computed waveform peaks (optional - will generate if not provided) */
+    peaks?: number[];
+    /** Whether to auto-play when loaded */
+    autoPlay?: boolean;
+    /** Whether to loop the audio */
+    loop?: boolean;
+    /** Initial volume (0-1) */
+    volume?: number;
+    /** Playback rate (0.5-2.0) */
+    rate?: number;
+    /** Whether to show player controls */
+    showControls?: boolean;
+    /** Which controls to display */
+    controls?: {
+        playPause?: boolean;
+        skip?: boolean;
+        volume?: boolean;
+        speed?: boolean;
+        download?: boolean;
+        share?: boolean;
+        waveform?: boolean;
+    };
+    /** Custom control layout */
+    controlsPosition?: 'top' | 'bottom' | 'overlay' | 'none';
+    /** Player theme variant */
+    variant?: 'minimal' | 'compact' | 'full' | 'soundcloud' | 'spotify';
+    /** Color scheme */
+    colorScheme?: 'light' | 'dark' | 'auto';
+    /** Called when audio is loaded and ready */
+    onLoad?: (data: AudioLoadData) => void;
+    /** Called when playback state changes */
+    onPlaybackStateChange?: (state: PlaybackState) => void;
+    /** Called during playback with current time */
+    onProgress?: (data: ProgressData) => void;
+    /** Called when playback finishes */
+    onEnd?: () => void;
+    /** Called on playback error */
+    onError?: (error: AudioError) => void;
+    /** Called when audio buffer updates */
+    onBuffer?: (data: BufferData) => void;
+    /** Whether to generate waveform from audio */
+    generateWaveform?: boolean;
+    /** Waveform generation options */
+    waveformOptions?: {
+        samples?: number;
+        precision?: number;
+        channel?: 'left' | 'right' | 'mix';
+    };
+    /** Show time labels */
+    showTime?: boolean;
+    /** Time format */
+    timeFormat?: 'mm:ss' | 'hh:mm:ss' | 'relative';
+    /** Show audio metadata */
+    showMetadata?: boolean;
+    /** Audio metadata */
+    metadata?: AudioMetadata;
+    /** Show spectrum analyzer */
+    showSpectrum?: boolean;
+    /** Spectrum analyzer options */
+    spectrumOptions?: SpectrumOptions;
+    /** Enable keyboard shortcuts */
+    enableKeyboardShortcuts?: boolean;
+    /** Custom keyboard shortcuts */
+    keyboardShortcuts?: KeyboardShortcuts;
+    /** Enable gesture controls */
+    enableGestures?: boolean;
+    /** Gesture configuration */
+    gestureConfig?: GestureConfig;
+    /** Enable audio effects */
+    enableEffects?: boolean;
+    /** Audio effects configuration */
+    effects?: AudioEffects;
+    /** Enable playlist support */
+    playlist?: PlaylistItem[];
+    /** Current playlist index */
+    currentTrack?: number;
+    /** Playlist callbacks */
+    onTrackChange?: (index: number, track: PlaylistItem) => void;
+    /** Enable audio export */
+    enableExport?: boolean;
+    /** Export options */
+    exportOptions?: {
+        formats?: ('mp3' | 'wav' | 'aac')[];
+        quality?: 'low' | 'medium' | 'high';
+    };
+    /** Custom share options */
+    shareOptions?: {
+        platforms?: ('copy' | 'email' | 'social')[];
+        includeTimestamp?: boolean;
+    };
+}
+export interface AudioLoadData {
+    duration: number;
+    sampleRate: number;
+    channels: number;
+    bitrate?: number;
+    format?: string;
+    peaks?: number[];
+}
+export interface PlaybackState {
+    isPlaying: boolean;
+    isLoading: boolean;
+    isBuffering: boolean;
+    currentTime: number;
+    duration: number;
+    volume: number;
+    rate: number;
+    loop: boolean;
+}
+export interface ProgressData {
+    currentTime: number;
+    duration: number;
+    progress: number;
+    position: number;
+    buffered: number;
+}
+export interface BufferData {
+    buffered: number;
+    bufferedRanges: {
+        start: number;
+        end: number;
+    }[];
+}
+export interface AudioError {
+    code: string;
+    message: string;
+    details?: any;
+}
+export interface AudioMetadata {
+    title?: string;
+    artist?: string;
+    album?: string;
+    artwork?: string;
+    duration?: number;
+    genre?: string;
+    year?: number;
+}
+export interface SpectrumOptions {
+    fftSize?: number;
+    smoothingTimeConstant?: number;
+    minDecibels?: number;
+    maxDecibels?: number;
+    bands?: number;
+    style?: 'bars' | 'line' | 'circular';
+}
+export interface KeyboardShortcuts {
+    playPause?: string;
+    skipForward?: string;
+    skipBackward?: string;
+    volumeUp?: string;
+    volumeDown?: string;
+    mute?: string;
+    seek?: string;
+}
+export interface GestureConfig {
+    doubleTapToPlay?: boolean;
+    swipeToSeek?: boolean;
+    pinchToZoom?: boolean;
+    longPressToScrub?: boolean;
+}
+export interface AudioEffects {
+    equalizer?: EqualizerSettings;
+    reverb?: ReverbSettings;
+    compressor?: CompressorSettings;
+    filters?: FilterSettings[];
+}
+export interface EqualizerSettings {
+    enabled: boolean;
+    bands: {
+        frequency: number;
+        gain: number;
+    }[];
+    preset?: 'rock' | 'pop' | 'jazz' | 'classical' | 'electronic' | 'custom';
+}
+export interface ReverbSettings {
+    enabled: boolean;
+    roomSize: number;
+    dampening: number;
+    wetLevel: number;
+    dryLevel: number;
+}
+export interface CompressorSettings {
+    enabled: boolean;
+    threshold: number;
+    ratio: number;
+    attack: number;
+    release: number;
+}
+export interface FilterSettings {
+    type: 'lowpass' | 'highpass' | 'bandpass' | 'notch';
+    frequency: number;
+    q: number;
+    gain?: number;
+}
+export interface PlaylistItem {
+    id: string;
+    source: string | number | {
+        uri: string;
+    };
+    title?: string;
+    artist?: string;
+    duration?: number;
+    artwork?: string;
+    peaks?: number[];
+    metadata?: AudioMetadata;
+}
+export interface AudioPlayerRef {
+    play: () => Promise<void>;
+    pause: () => Promise<void>;
+    stop: () => Promise<void>;
+    seek: (time: number) => Promise<void>;
+    setVolume: (volume: number) => Promise<void>;
+    setRate: (rate: number) => Promise<void>;
+    setLoop: (loop: boolean) => Promise<void>;
+    getCurrentTime: () => Promise<number>;
+    getDuration: () => Promise<number>;
+    getPlaybackState: () => PlaybackState;
+    load: (source: string | number | {
+        uri: string;
+    }) => Promise<void>;
+    unload: () => Promise<void>;
+    exportAudio: (format: string, options?: any) => Promise<string>;
+    getWaveformPeaks: () => number[];
+    setSelection: (start: number, end: number) => void;
+    clearSelection: () => void;
+}

package/lib/components/AutoComplete/AutoComplete.d.ts

@@ -0,0 +1,6 @@
+import { View } from 'react-native';
+import type { AutoCompleteProps } from './types';
+export declare const AutoComplete: import("../../core/factory").PlatformBlocksComponent<{
+    props: AutoCompleteProps;
+    ref: View;
+}>;

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

@@ -0,0 +1,2 @@
+export { AutoComplete } from './AutoComplete';
+export type { AutoCompleteProps, AutoCompleteOption } from './types';

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

@@ -0,0 +1,120 @@
+import React from 'react';
+import { TextInputProps, ViewStyle } from 'react-native';
+import { SpacingProps, LayoutProps } from '../../core/utils';
+import type { SizeValue } from '../../core/theme/types';
+import type { RadiusValue } from '../../core/theme/radius';
+import type { ChipProps } from '../Chip/types';
+export interface AutoCompleteOption {
+    label: string;
+    value: string;
+    group?: string;
+    disabled?: boolean;
+    data?: any;
+}
+export interface AutoCompleteProps extends SpacingProps, LayoutProps {
+    /** Input label */
+    label?: string;
+    /** Description text below the input */
+    description?: string;
+    /** Helper text displayed below the field when no error is present */
+    helperText?: string;
+    /** Whether the field is required */
+    required?: boolean;
+    /** Error message */
+    error?: string;
+    /** Input value */
+    value?: string;
+    /** Change handler */
+    onChangeText?: (text: string) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the input is disabled */
+    disabled?: boolean;
+    /** Controls input size (affects padding and height) */
+    size?: SizeValue;
+    /** Controls border radius; accepts size tokens or numeric value */
+    radius?: RadiusValue;
+    /** Show built-in clear button when there is text */
+    clearable?: boolean;
+    /** Accessible label for the clear button */
+    clearButtonLabel?: string;
+    /** Callback when the clear button is pressed */
+    onClear?: () => void;
+    /** Custom style */
+    style?: ViewStyle;
+    /** Data source for suggestions */
+    data?: AutoCompleteOption[];
+    /** Async data fetcher */
+    onSearch?: (query: string) => Promise<AutoCompleteOption[]>;
+    /** Minimum characters to trigger search */
+    minSearchLength?: number;
+    /** Search debounce delay */
+    searchDelay?: number;
+    /** Custom item renderer */
+    renderItem?: (item: AutoCompleteOption, index: number, options: {
+        query: string;
+        onSelect: (item: AutoCompleteOption) => void;
+        isHighlighted?: boolean;
+        isSelected?: boolean;
+    }) => React.ReactNode;
+    /** Selection handler */
+    onSelect?: (item: AutoCompleteOption) => void;
+    /** Whether to allow custom values */
+    allowCustomValue?: boolean;
+    /** Maximum number of suggestions to display */
+    maxSuggestions?: number;
+    /** Whether to show suggestions on focus (default: true) */
+    showSuggestionsOnFocus?: boolean;
+    /** Custom empty state component */
+    renderEmptyState?: () => React.ReactNode;
+    /** Custom loading state component */
+    renderLoadingState?: () => React.ReactNode;
+    /** Filter function for local data */
+    filter?: (item: AutoCompleteOption, query: string) => boolean;
+    /** Whether to highlight matching text */
+    highlightMatches?: boolean;
+    /** Custom styles for suggestions container */
+    suggestionsStyle?: any;
+    /** Custom styles for suggestion items */
+    suggestionItemStyle?: any;
+    /** Enable multi-select mode */
+    multiSelect?: boolean;
+    /** Selected values for multi-select mode */
+    selectedValues?: AutoCompleteOption[];
+    /** Custom renderer for each selected value chip in multi-select mode */
+    renderSelectedValue?: (item: AutoCompleteOption, index: number, context: {
+        onRemove: () => void;
+        disabled: boolean;
+        isFocused: boolean;
+        inputValue: string;
+        source: 'input' | 'modal';
+    }) => React.ReactNode;
+    /** Optional style override for the selected values container */
+    selectedValuesContainerStyle?: ViewStyle;
+    /** Additional props applied to the default Chip renderer for selected values */
+    selectedValueChipProps?: Partial<ChipProps>;
+    /** Whether to allow free-form input (can add custom values) */
+    freeSolo?: boolean;
+    /** What to display in input after selection - 'label' or 'value' */
+    displayProperty?: 'label' | 'value';
+    /** Whether to render suggestions in a modal for guaranteed top layering */
+    useModal?: boolean;
+    /** Whether to render suggestions in a portal for proper z-index handling (default: true) */
+    usePortal?: boolean;
+    /** Explicit width for the input container (overrides layout width) */
+    inputWidth?: number | string;
+    /** Minimum width (particularly helpful on Android where intrinsic shrink can occur) */
+    minWidth?: number;
+    /** Additional TextInput props */
+    textInputProps?: Omit<TextInputProps, 'value' | 'onChangeText' | 'placeholder'>;
+    /** Placement preference for the suggestions dropdown (default: 'bottom-start') */
+    placement?: 'auto' | 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end' | 'right-start' | 'right-end';
+    /** Enable flipping to opposite side when dropdown would go off-screen (default: true) */
+    flip?: boolean;
+    /** Enable shifting within bounds when dropdown would go off-screen (default: true) */
+    shift?: boolean;
+    /** Distance from viewport edges in pixels (default: 12) */
+    boundary?: number;
+    /** Enable automatic repositioning on scroll/resize (default: true) */
+    autoReposition?: boolean;
+}

package/lib/components/Avatar/Avatar.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { AvatarProps } from './types';
+export declare function Avatar({ size, src, fallback, backgroundColor, textColor, online, badgeColor, style, accessibilityLabel, label, description, gap, showText, }: AvatarProps): React.JSX.Element;

package/lib/components/Avatar/AvatarGroup.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { AvatarGroupProps } from './types';
+export declare function AvatarGroup({ children, limit, spacing, style, size, bordered, }: AvatarGroupProps): React.JSX.Element;

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

@@ -0,0 +1,3 @@
+export { Avatar } from './Avatar';
+export { AvatarGroup } from './AvatarGroup';
+export type { AvatarProps, AvatarGroupProps } from './types';

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

@@ -0,0 +1,30 @@
+import React from 'react';
+import { ViewStyle } from 'react-native';
+export interface AvatarProps {
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+    src?: string;
+    fallback?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    online?: boolean;
+    badgeColor?: string;
+    style?: ViewStyle;
+    accessibilityLabel?: string;
+    /** Primary label displayed to the right of the avatar (string or custom React node) */
+    label?: React.ReactNode;
+    /** Secondary description/subtext under the label */
+    description?: React.ReactNode;
+    /** Spacing between avatar and text block */
+    gap?: number;
+    /** Force horizontal layout off (set false to hide label/description wrapper) */
+    showText?: boolean;
+}
+export interface AvatarGroupProps {
+    children: React.ReactNode;
+    limit?: number;
+    spacing?: number;
+    style?: ViewStyle;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+    /** Whether to add borders around avatars for separation */
+    bordered?: boolean;
+}

package/lib/components/Badge/Badge.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { BadgeProps } from './types';
+export declare const Badge: React.FC<BadgeProps>;
+export default Badge;

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

@@ -0,0 +1,3 @@
+export { Badge } from './Badge';
+export type { BadgeProps } from './types';
+export { Badge as default } from './Badge';

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

@@ -0,0 +1,26 @@
+import React from 'react';
+import { ViewStyle, TextStyle } from 'react-native';
+import { SizeValue } from '../../core/theme/sizes';
+import { SpacingProps } from '../../core/utils';
+import { BorderRadiusProps } from '../../core/theme/radius';
+import { ShadowProps } from '../../core/theme/shadow';
+export interface BadgeProps extends SpacingProps, BorderRadiusProps, ShadowProps {
+    children: React.ReactNode;
+    size?: SizeValue;
+    variant?: 'filled' | 'outline' | 'light' | 'subtle';
+    /** Alias for variant */
+    v?: 'filled' | 'outline' | 'light' | 'subtle';
+    color?: 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'gray' | string;
+    /** Alias for color */
+    c?: 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'gray' | string;
+    onPress?: () => void;
+    startIcon?: React.ReactNode;
+    endIcon?: React.ReactNode;
+    onRemove?: () => void;
+    removePosition?: 'left' | 'right';
+    disabled?: boolean;
+    style?: ViewStyle;
+    textStyle?: TextStyle;
+    radius?: any;
+    shadow?: any;
+}

package/lib/components/Block/Block.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import type { BlockProps } from './types';
+/**
+ * Block - A polymorphic building block component
+ *
+ * The Block component serves as a foundational building block that can replace View components
+ * throughout the application. It provides a consistent API for styling, spacing, and layout
+ * while supporting polymorphic rendering (can render as any HTML element or React component).
+ *
+ * Key features:
+ * - Polymorphic: Can render as any element via the `component` prop
+ * - Spacing system: Supports margin/padding shorthand props (m, p, mx, py, etc.)
+ * - Layout utilities: Flexbox, positioning, dimensions
+ * - Theming: Consistent radius, shadow, and color values
+ * - Accessibility: Full accessibility prop support
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <Block bg="blue.500" p="md" radius="lg">
+ *   Content
+ * </Block>
+ *
+ * // As a button
+ * <Block component="button" bg="green.500" p="sm" radius="md">
+ *   Click me
+ * </Block>
+ *
+ * // Flex layout
+ * <Block direction="row" justify="space-between" align="center" gap="md">
+ *   <Block>Item 1</Block>
+ *   <Block>Item 2</Block>
+ * </Block>
+ * ```
+ */
+export declare const Block: React.ForwardRefExoticComponent<BlockProps & React.RefAttributes<any>>;

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

@@ -0,0 +1,2 @@
+export { Block } from './Block';
+export type { BlockProps, BlockStyleProps, BlockFactory } from './types';

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

@@ -0,0 +1,102 @@
+import React from 'react';
+import { ViewStyle } from 'react-native';
+import type { SpacingProps } from '../../core/utils/spacing';
+import type { PolymorphicFactory } from '../../core/factory';
+/**
+ * Base styling props for the Block component
+ */
+export interface BlockStyleProps {
+    /** Background color for the block */
+    bg?: string;
+    /** Border radius for rounded corners */
+    radius?: number | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    /** Border width */
+    borderWidth?: number;
+    /** Border color */
+    borderColor?: string;
+    /** Shadow depth (0-5) */
+    shadow?: number | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Opacity (0-1) */
+    opacity?: number;
+    /** Width of the block */
+    w?: number | string | 'auto' | 'full';
+    /** Height of the block */
+    h?: number | string | 'auto' | 'full';
+    /** Whether to take full width (100%) - shorthand for w="full" */
+    fullWidth?: boolean;
+    /** Makes block take full available height (flex: 1) - useful for scrollable containers */
+    fluid?: boolean;
+    /** Minimum width */
+    minW?: number | string;
+    /** Minimum height */
+    minH?: number | string;
+    /** Maximum width */
+    maxW?: number | string;
+    /** Maximum height */
+    maxH?: number | string;
+    /** Flex grow */
+    grow?: boolean | number;
+    /** Flex shrink */
+    shrink?: boolean | number;
+    /** Flex basis */
+    basis?: number | string;
+    /** Flex direction */
+    direction?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+    /** Align items */
+    align?: 'stretch' | 'flex-start' | 'flex-end' | 'center' | 'baseline';
+    /** Justify content */
+    justify?: 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+    /** Flex wrap */
+    wrap?: boolean | 'nowrap' | 'wrap' | 'wrap-reverse';
+    /** Gap between children */
+    gap?: number | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Position type */
+    position?: 'relative' | 'absolute';
+    /** Top position */
+    top?: number | string;
+    /** Right position */
+    right?: number | string;
+    /** Bottom position */
+    bottom?: number | string;
+    /** Left position */
+    left?: number | string;
+    /** Start position (logical property - becomes left in LTR, right in RTL) */
+    start?: number | string;
+    /** End position (logical property - becomes right in LTR, left in RTL) */
+    end?: number | string;
+    /** Z-index */
+    zIndex?: number;
+    /** Whether to render as a flex container */
+    flex?: boolean;
+}
+/**
+ * Props for the Block component.
+ * A polymorphic building block component that can render as any element.
+ */
+export interface BlockProps extends SpacingProps, BlockStyleProps {
+    /** Child elements to render inside the block */
+    children?: React.ReactNode;
+    /** The component to render as */
+    component?: React.ElementType;
+    /** Custom style object */
+    style?: ViewStyle;
+    /** Test ID for testing purposes */
+    testID?: string;
+    /** Accessibility label */
+    accessibilityLabel?: string;
+    /** Whether the element is accessible */
+    accessible?: boolean;
+    /** Accessibility role */
+    accessibilityRole?: string;
+    /** Custom className (for web) */
+    className?: string;
+}
+/**
+ * Factory type for the Block component
+ */
+export type BlockFactory = PolymorphicFactory<{
+    props: BlockProps;
+    ref: HTMLDivElement;
+    defaultComponent: 'div';
+    defaultRef: HTMLDivElement;
+}>;

package/lib/components/Block/utils.d.ts

@@ -0,0 +1,28 @@
+import { ViewStyle, DimensionValue } from 'react-native';
+import type { BlockStyleProps } from './types';
+/**
+ * Maps radius values to numeric pixels
+ */
+export declare function getRadius(radius: BlockStyleProps['radius']): number | undefined;
+/**
+ * Maps shadow values to shadow styles
+ */
+export declare function getShadow(shadow: BlockStyleProps['shadow']): {
+    boxShadow?: undefined;
+    elevation?: undefined;
+} | {
+    boxShadow: string;
+    elevation: number;
+};
+/**
+ * Maps width/height values to styles
+ */
+export declare function getDimension(value: BlockStyleProps['w']): DimensionValue | undefined;
+/**
+ * Maps gap values to numeric spacing
+ */
+export declare function getGap(gap: BlockStyleProps['gap']): number | undefined;
+/**
+ * Converts Block style props to React Native ViewStyle
+ */
+export declare function getBlockStyles(props: BlockStyleProps, isRTL?: boolean): ViewStyle;

package/lib/components/Blockquote/Blockquote.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { BlockquoteProps } from './types';
+export declare function Blockquote({ children, variant, size, color, quoteIcon, quoteIconPosition, quoteIconSize, author, links, date, rating, source, verified, verifiedTooltip, alignment, border, shadow, style, onPress, }: BlockquoteProps): React.JSX.Element;

package/lib/components/Blockquote/BlockquoteAttribution.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { BlockquoteAttributionProps } from './types';
+export declare function BlockquoteAttribution({ author, date, rating, source, links, verified, verifiedTooltip, alignment, }: BlockquoteAttributionProps): React.JSX.Element;

package/lib/components/Blockquote/BlockquoteAuthor.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { BlockquoteAuthorProps } from './types';
+export declare function BlockquoteAuthor({ author, alignment, }: BlockquoteAuthorProps): React.JSX.Element;

package/lib/components/Blockquote/BlockquoteMeta.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { BlockquoteMetaProps } from './types';
+export declare function BlockquoteMeta({ date, rating, verified, verifiedTooltip, alignment, }: BlockquoteMetaProps): React.JSX.Element;

package/lib/components/Blockquote/BlockquoteSource.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { BlockquoteSourceProps } from './types';
+export declare function BlockquoteSource({ source, alignment, }: BlockquoteSourceProps): React.JSX.Element;

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

@@ -0,0 +1,6 @@
+export { Blockquote } from './Blockquote';
+export { BlockquoteAttribution } from './BlockquoteAttribution';
+export { BlockquoteAuthor } from './BlockquoteAuthor';
+export { BlockquoteSource } from './BlockquoteSource';
+export { BlockquoteMeta } from './BlockquoteMeta';
+export type { BlockquoteProps, BlockquoteAuthor as BlockquoteAuthorType, BlockquoteLinks, BlockquoteRating, BlockquoteSource as BlockquoteSourceType, BlockquoteAttributionProps, BlockquoteAuthorProps, BlockquoteSourceProps, BlockquoteMetaProps, } from './types';