react-motion-gallery 2.0.19 → 2.0.21

package/dist/responsive-D_xhZmVI.d.mts

@@ -1,186 +0,0 @@
-import * as React$1 from 'react';
-import { M as MediaItem, P as PlyrSourceBuilder, a as PlyrOptionsBuilder } from './plyrTypes-Cq4C3ul5.mjs';
-import { a as ZoomPanOptions } from './types-Dhh8xfHo.mjs';
-
-type ElementStyle = {
-    className?: string;
-    style?: React.CSSProperties;
-};
-
-type LoadingTimingOptions = {
-    exitMs?: number;
-    minVisibleMs?: number;
-};
-
-type IndexMode = "animated" | "instant";
-type FullscreenOpenMethod = "fade" | "scale";
-type OpenFullscreenAtArgs = {
-    index: number;
-    method?: FullscreenOpenMethod;
-    event?: Event;
-};
-type FullscreenOpenSource = "slider" | "grid" | "masonry" | "entries" | "api";
-type FullscreenOpenRequest = {
-    source: FullscreenOpenSource;
-    index: number;
-    image: HTMLImageElement | null;
-    method?: FullscreenOpenMethod;
-    requestedMethod?: FullscreenOpenMethod;
-    event?: Event;
-};
-interface GalleryApi {
-    rootNode(): HTMLElement | null;
-    containerNode(): HTMLElement | null;
-    getViewportNode: () => HTMLDivElement | null;
-    slideNodes(): HTMLElement[];
-    onReady?(cb: (nodes: HTMLElement[]) => void): () => void;
-    whenReady?(): Promise<HTMLElement[]>;
-    isReady?(): boolean;
-    scrollTo(index: number, jump?: boolean): void;
-    scrollNext(jump?: boolean): void;
-    scrollPrev(jump?: boolean): void;
-    canScrollNext(): boolean;
-    canScrollPrev(): boolean;
-    getIndex(): number;
-    selectCell(index: number, jump?: boolean): void;
-    scrollProgress(): number;
-    cellsInView(): number[];
-    append(nodes: React.ReactNode | React.ReactNode[]): number;
-    prepend(nodes: React.ReactNode | React.ReactNode[]): number;
-    insert(index: number, nodes: React.ReactNode | React.ReactNode[]): number;
-    remove(indexOrPredicate: number | ((i: number) => boolean)): number;
-    replace(index: number, node: React.ReactNode): void;
-    setItems(nodes: React.ReactNode[]): number;
-    onIndexChange(cb: (i: number, meta: {
-        mode: IndexMode;
-    }) => void): () => void;
-    openFullscreenAt: (args: OpenFullscreenAtArgs) => void;
-}
-
-type FsCounterArgs = {
-    index: number;
-    count: number;
-};
-type FsCaptionPlacement = "top" | "right" | "bottom" | "left";
-type FsIntroRequest = null | {
-    originalImage: HTMLImageElement | null;
-    index: number;
-    method: FullscreenOpenMethod;
-    closestSelector?: string;
-};
-type FSImageRender = (args: {
-    item: Extract<MediaItem, {
-        kind: "image";
-    }>;
-    index: number;
-    isZoomed: boolean;
-    className: string;
-    baseStyle: React$1.CSSProperties;
-}) => React$1.ReactNode;
-type FullscreenArrows = {
-    enabled?: boolean;
-    arrow?: ElementStyle;
-    prev?: ElementStyle;
-    next?: ElementStyle;
-    render?: (args: {
-        dir: "prev" | "next";
-    }) => React$1.ReactNode;
-    renderPrev?: () => React$1.ReactNode;
-    renderNext?: () => React$1.ReactNode;
-};
-type FullscreenClose = {
-    enabled?: boolean;
-    style?: React$1.CSSProperties;
-    className?: string;
-    render?: () => React$1.ReactNode;
-};
-type FullscreenCounter = {
-    enabled?: boolean;
-    style?: React$1.CSSProperties;
-    className?: string;
-    render?: (args: FsCounterArgs) => React$1.ReactNode;
-};
-type FullscreenControlsOptions = {
-    close?: FullscreenClose;
-    arrows?: FullscreenArrows;
-    counter?: FullscreenCounter;
-};
-type FsCaptionRenderArgs = {
-    item: MediaItem;
-    index: number;
-    isZoomed: boolean;
-};
-type FullscreenCaptionOptions = {
-    className?: string;
-    style?: React$1.CSSProperties;
-    width?: ResponsiveLength;
-    height?: ResponsiveLength;
-    placement?: ResponsiveCaptionPlacement;
-    breakpoint?: number;
-    render?: (args: FsCaptionRenderArgs) => React$1.ReactNode;
-    layout?: "overlay" | "slide";
-    overlayCrossfadeTarget?: "content" | "overlay";
-    zoomFade?: boolean;
-    zoomFadeDurationMs?: number;
-    zoomFadeEasing?: string;
-    zoomInTransform?: string;
-    zoomOutTransform?: string;
-};
-type FullscreenEffectsOptions = {
-    introDuration?: number;
-    introEasing?: string;
-    introFade?: boolean;
-    introStickyNavSelector?: string;
-    controlsFade?: boolean;
-    dragFade?: boolean;
-    slideFadeDuration?: number;
-    slideFadeEasing?: string;
-};
-type FullscreenSliderOptions = {
-    duration?: number;
-    friction?: number;
-    direction?: "ltr" | "rtl";
-};
-type FullscreenZoomPanOptions = ZoomPanOptions;
-type FullscreenVideoOptions = {
-    source?: PlyrSourceBuilder;
-    options?: PlyrOptionsBuilder;
-    style?: React$1.CSSProperties;
-    className?: string;
-};
-type FullscreenLazyLoadKind = "image" | "video";
-type FullscreenLazyLoadArgs = {
-    kind: FullscreenLazyLoadKind;
-    isClone?: boolean;
-};
-type FullscreenLazyLoadConfig = {
-    enabled?: boolean;
-    spinner?: boolean | React$1.ReactNode | ((args: FullscreenLazyLoadArgs) => React$1.ReactNode);
-    spinnerClassName?: string;
-    spinnerStyle?: React$1.CSSProperties;
-};
-type FullscreenLazyLoadOptions = {
-    images?: FullscreenLazyLoadConfig;
-    videos?: FullscreenLazyLoadConfig;
-};
-type FullscreenOptions = {
-    enabled?: boolean;
-    items?: MediaItem[] | string[];
-    renderImage?: FSImageRender;
-    video?: FullscreenVideoOptions;
-    controls?: FullscreenControlsOptions;
-    caption?: FullscreenCaptionOptions;
-    slider?: FullscreenSliderOptions;
-    zoom?: FullscreenZoomPanOptions;
-    effects?: FullscreenEffectsOptions;
-    lazyLoad?: FullscreenLazyLoadOptions;
-};
-
-declare const BREAKPOINT_MAP: Record<string, number>;
-type BreakpointMap = Record<string, number>;
-type ResponsiveNumber = number | Record<string, number>;
-type ResponsiveLengthValue = number | string;
-type ResponsiveLength = ResponsiveLengthValue | Record<string, ResponsiveLengthValue>;
-type ResponsiveCaptionPlacement = FsCaptionPlacement | Array<FsCaptionPlacement> | Record<string, FsCaptionPlacement>;
-
-export { BREAKPOINT_MAP as B, type ElementStyle as E, type FullscreenOptions as F, type GalleryApi as G, type IndexMode as I, type LoadingTimingOptions as L, type OpenFullscreenAtArgs as O, type ResponsiveNumber as R, type FsCaptionPlacement as a, type FsIntroRequest as b, type BreakpointMap as c, type ResponsiveLength as d, type ResponsiveCaptionPlacement as e, type FullscreenOpenRequest as f, type FullscreenClose as g, type FullscreenArrows as h, type FullscreenCounter as i, type FsCaptionRenderArgs as j, type FSImageRender as k, type FullscreenVideoOptions as l, type FullscreenLazyLoadOptions as m };

package/dist/sliderSub-Bo6Y8as_.d.mts

@@ -1,45 +0,0 @@
-import { I as IndexMode } from './responsive-D_xhZmVI.mjs';
-
-type IndexListener = () => void;
-type IndexEventMeta = {
-    source?: "thumbnail" | "external";
-    transition?: "scroll" | "crossfade";
-    crossfade?: {
-        durationMs?: number;
-        easing?: string;
-    };
-};
-type IndexEvent = {
-    type: "set";
-    index: number;
-    mode: IndexMode;
-    meta?: IndexEventMeta;
-} | {
-    type: "bump";
-    delta: number;
-    mode: IndexMode;
-    meta?: IndexEventMeta;
-};
-type EventListener = (ev: IndexEvent) => void;
-type BasePointerDownListener = () => void;
-type SliderIndexChannel = ReturnType<typeof createSliderIndexChannel>;
-declare function createSliderIndexChannel(initialIndex?: number, initialMode?: IndexMode): {
-    get(): {
-        index: number;
-        mode: IndexMode;
-    };
-    set(next: number, m?: IndexMode, opts?: {
-        silent?: boolean;
-        meta?: IndexEventMeta;
-    }): void;
-    bump(delta: number, m?: IndexMode, opts?: {
-        silent?: boolean;
-        meta?: IndexEventMeta;
-    }): void;
-    subscribe(fn: IndexListener): () => void;
-    onEvent(fn: EventListener): () => void;
-    onBasePointerDown(fn: BasePointerDownListener): () => void;
-    emitBasePointerDown: () => void;
-};
-
-export { type SliderIndexChannel as S, createSliderIndexChannel as c };

package/dist/text-Cl2tR8oO.d.mts

@@ -1,4 +0,0 @@
-type ResponsiveTextLineCount = number | Record<string, number>;
-type ResponsiveTextLineWidth = number | string | Record<string, number | string>;
-
-export type { ResponsiveTextLineCount as R, ResponsiveTextLineWidth as a };

package/dist/types-DY058l5M.d.mts

@@ -1,301 +0,0 @@
-import { I as IndexMode, R as ResponsiveNumber, E as ElementStyle, L as LoadingTimingOptions } from './responsive-D_xhZmVI.mjs';
-import { A as ArrowRenderArgs, D as DotsRenderArgs, P as ProgressRenderArgs, S as ScrollbarRenderArgs } from './controls-SpWg1Kgt.mjs';
-import * as React$1 from 'react';
-import { RefObject } from 'react';
-import { R as ResponsiveTextLineCount, a as ResponsiveTextLineWidth } from './text-Cl2tR8oO.mjs';
-import { S as SliderIndexChannel } from './sliderSub-Bo6Y8as_.mjs';
-
-type SkeletonLength = number | string;
-type SkeletonShimmer = {
-    enabled?: boolean;
-    durationMs?: number;
-    angleDeg?: number;
-    opacity?: number;
-    blurPx?: number;
-    timing?: string;
-    c1?: string;
-    c2?: string;
-    c3?: string;
-};
-type SkeletonBaseStyle = {
-    width?: SkeletonLength;
-    maxWidth?: SkeletonLength;
-    height?: SkeletonLength;
-    maxHeight?: SkeletonLength;
-    backgroundColor?: string;
-    borderRadius?: SkeletonLength;
-    overflow?: React$1.CSSProperties["overflow"];
-    marginTop?: SkeletonLength;
-    marginRight?: SkeletonLength;
-    marginBottom?: SkeletonLength;
-    marginLeft?: SkeletonLength;
-    alignSelf?: React$1.CSSProperties["alignSelf"];
-    aspectRatio?: SkeletonLength;
-    scale?: number;
-};
-type SkeletonBaseStyleResponsive = SkeletonBaseStyle | Record<string, SkeletonBaseStyle>;
-type SliderSkeletonWrapStyle = SkeletonBaseStyle & {
-    border?: React$1.CSSProperties["border"];
-    boxShadow?: React$1.CSSProperties["boxShadow"];
-};
-type SkeletonContainerStyle = {
-    gap?: SkeletonLength;
-    padding?: SkeletonLength;
-    align?: React$1.CSSProperties["alignItems"];
-    justify?: React$1.CSSProperties["justifyContent"];
-    wrap?: boolean;
-    width?: SkeletonLength;
-    maxWidth?: SkeletonLength;
-    overflow?: React$1.CSSProperties["overflow"];
-};
-type SkeletonContainerStyleResponsive = SkeletonContainerStyle | Record<string, SkeletonContainerStyle>;
-type SliderSkeletonSlot = {
-    item?: SkeletonNode;
-    itemWrapStyle?: SliderSkeletonWrapStyle;
-};
-type SliderSkeletonSliderNode = {
-    kind: "slider";
-    style?: SkeletonContainerStyleResponsive;
-    count?: number;
-    item: SkeletonNode;
-    itemWrapStyle?: SliderSkeletonWrapStyle;
-    slots?: SliderSkeletonSlot[];
-    direction?: "row" | "col";
-    children?: SkeletonNode[];
-};
-type SliderSkeletonNode = SliderSkeletonSliderNode | SkeletonNode;
-type SkeletonNode = {
-    kind: "stack" | "row" | "col";
-    style?: SkeletonContainerStyleResponsive;
-    children: SkeletonNode[];
-} | {
-    kind: "rect" | "square" | "circle";
-    style?: SkeletonBaseStyleResponsive;
-    shimmer?: SkeletonShimmer;
-} | {
-    kind: "media";
-    count: number;
-    direction?: "row" | "col";
-    style?: SkeletonContainerStyleResponsive;
-    tile?: {
-        shape?: "rect" | "square" | "circle";
-        style?: SkeletonBaseStyleResponsive;
-        shimmer?: SkeletonShimmer;
-    };
-} | {
-    kind: "text";
-    fontSize: number;
-    lineHeight: number;
-    lines?: ResponsiveTextLineCount;
-    lineWidth?: ResponsiveTextLineWidth;
-    style?: SkeletonBaseStyleResponsive;
-    shimmer?: SkeletonShimmer;
-};
-type SliderSkeletonSpec = {
-    mode?: "fit" | "peek";
-    centering?: "first";
-    className?: string;
-    style?: React$1.CSSProperties;
-    layout?: SliderSkeletonNode;
-    backgroundColor?: string;
-    radius?: SkeletonLength;
-    shimmer?: SkeletonShimmer;
-};
-
-type ResponsiveHeightRule = {
-    query: string;
-    height: string;
-};
-type SliderLayout = {
-    gap?: number;
-    cellsPerSlide?: ResponsiveNumber;
-};
-type SliderDirection = {
-    dir?: "ltr" | "rtl";
-    axis?: "x" | "y";
-};
-type SliderElements = {
-    viewport?: ElementStyle;
-    container?: ElementStyle;
-};
-type SliderScroll = {
-    groupCells?: boolean;
-    skipSnaps?: boolean;
-    freeScroll?: boolean;
-    loop?: boolean;
-};
-type SliderArrows = {
-    enabled?: boolean;
-    arrow?: ElementStyle;
-    prev?: ElementStyle;
-    next?: ElementStyle;
-    render?: (args: ArrowRenderArgs & {
-        dir: "prev" | "next";
-    }) => React.ReactNode;
-    renderPrev?: (args: ArrowRenderArgs) => React.ReactNode;
-    renderNext?: (args: ArrowRenderArgs) => React.ReactNode;
-};
-type SliderDots = {
-    enabled?: boolean;
-    root?: ElementStyle;
-    dot?: ElementStyle;
-    render?: (args: DotsRenderArgs) => React.ReactNode;
-};
-type SliderProgress = {
-    enabled?: boolean;
-    root?: ElementStyle;
-    bar?: ElementStyle;
-    render?: (args: ProgressRenderArgs) => React.ReactNode;
-};
-type SliderScrollbar = {
-    enabled?: boolean;
-    root?: ElementStyle;
-    render?: (args: ScrollbarRenderArgs) => React.ReactNode;
-};
-type SliderRipple = {
-    enabled?: boolean;
-    className?: string;
-};
-type SliderControls = {
-    arrows?: SliderArrows;
-    dots?: SliderDots;
-    progress?: SliderProgress;
-    scrollbar?: SliderScrollbar;
-    ripple?: SliderRipple;
-};
-type SliderAutoPlay = {
-    enabled?: boolean;
-    speedMs?: number;
-    pauseMs?: number;
-    pauseOnHover?: boolean;
-};
-type SliderAutoScroll = {
-    enabled?: boolean;
-    speedMs?: number;
-    pauseMs?: number;
-    pauseOnHover?: boolean;
-};
-type SliderAuto = {
-    play?: SliderAutoPlay;
-    scroll?: SliderAutoScroll;
-};
-type SliderLoadingOptions = {
-    enabled?: boolean;
-    force?: boolean;
-    skeletonCount?: ResponsiveNumber;
-    renderLoading?: (args: {
-        count: number;
-    }) => React.ReactNode;
-    skeleton?: SliderSkeletonSpec;
-    timing?: LoadingTimingOptions;
-};
-type SliderIntroOptions = {
-    renderIntro?: (args: {
-        active: boolean;
-        containerProps: React.HTMLAttributes<HTMLDivElement>;
-    }, content: React.ReactNode) => React.ReactNode;
-    staggerMs?: number;
-    durationMs?: number;
-    easing?: string;
-};
-type SliderTransitions = {
-    loading?: SliderLoadingOptions;
-    intro?: SliderIntroOptions;
-};
-type SliderParallax = {
-    enabled?: boolean;
-    bleedPct?: string;
-    borderRadius?: string;
-    sideWidth?: string;
-};
-type SliderScale = {
-    enabled?: boolean;
-    amount?: number;
-};
-type SliderFade = {
-    enabled?: boolean;
-    minOpacity?: number;
-};
-type CrossFade = {
-    controls?: boolean;
-    drag?: boolean;
-    durationMs?: number;
-    easing?: string;
-};
-type SliderEffects = {
-    parallax?: SliderParallax;
-    scale?: SliderScale;
-    fade?: SliderFade;
-    crossfade?: CrossFade;
-};
-type SliderMotion = {
-    selectDuration?: number;
-    freeScrollDuration?: number;
-    friction?: number;
-};
-type SliderLazyLoadOptions = {
-    enabled?: boolean;
-    spinner?: boolean | React.ReactNode | ((args: {
-        kind: "image" | "video";
-        isClone: boolean;
-    }) => React.ReactNode);
-    spinnerClassName?: string;
-    spinnerStyle?: React.CSSProperties;
-};
-type SliderOptions = {
-    layout?: SliderLayout;
-    direction?: SliderDirection;
-    align?: "start" | "center";
-    scroll?: SliderScroll;
-    elements?: SliderElements;
-    lazyLoad?: SliderLazyLoadOptions;
-    controls?: SliderControls;
-    auto?: SliderAuto;
-    transitions?: SliderTransitions;
-    motion?: SliderMotion;
-    effects?: SliderEffects;
-    indexChannel?: SliderIndexChannel;
-};
-type SliderUiSelectOptions = {
-    crossfade?: boolean;
-    durationMs?: number;
-    easing?: string;
-};
-interface SliderHandle {
-    centerSlider: () => void;
-    getIndex: () => number;
-    setIndex: (i: number, mode?: IndexMode) => void;
-    subscribeIndex: (fn: () => void) => () => void;
-    slideIndexForCell: (cellIndex: number) => number;
-    getRootNode(): HTMLElement | null;
-    getContainerNode(): HTMLElement | null;
-    getSlideNodes(): HTMLElement[];
-    getViewportNode: () => HTMLDivElement | null;
-    onSlidesBuilt(cb: (nodes: HTMLElement[]) => void): () => void;
-    whenSlidesBuilt(): Promise<HTMLElement[]>;
-    isSlidesBuilt(): boolean;
-    scrollNext: (mode?: IndexMode) => void;
-    scrollPrev: (mode?: IndexMode) => void;
-    canScrollNext: () => boolean;
-    canScrollPrev: () => boolean;
-    scrollProgress: () => number;
-    cellsInView: () => number[];
-    getInternals(): {
-        slides: RefObject<{
-            cells: {
-                element: HTMLElement;
-                index: number;
-            }[];
-            target: number;
-        }[]>;
-        slider: RefObject<HTMLDivElement | null>;
-        visibleImages: RefObject<number>;
-        selectedIndex: RefObject<number>;
-        sliderX: RefObject<number>;
-        sliderVelocity: RefObject<number>;
-        isWrapping: RefObject<boolean>;
-    };
-    setIndexFromUi: (i: number, opts?: SliderUiSelectOptions) => void;
-}
-
-export type { ResponsiveHeightRule as R, SliderOptions as S, SliderHandle as a };

package/dist/types-VULXzSa2.d.mts

@@ -1,68 +0,0 @@
-import { L as LoadingTimingOptions, R as ResponsiveNumber } from './responsive-D_xhZmVI.mjs';
-import { S as SkeletonLayoutRoot, a as SkeletonNode$1, b as SkeletonWrapStyle, c as SkeletonLength, d as SkeletonShimmer, G as GalleryLazyLoadOptions } from './layout-CR6f2aPH.mjs';
-
-type MasonrySkeletonWrapStyle = SkeletonWrapStyle;
-type SkeletonNode = SkeletonNode$1;
-type MasonrySkeletonSlot = {
-    item?: SkeletonNode;
-    itemWrapStyle?: MasonrySkeletonWrapStyle;
-    ratio?: number;
-    heightPx?: number;
-};
-type MasonrySkeletonLayoutNode = SkeletonLayoutRoot<"masonry"> & {
-    slots?: MasonrySkeletonSlot[];
-};
-type MasonrySkeletonNode = MasonrySkeletonLayoutNode | SkeletonNode$1;
-type MasonrySkeletonSpec = {
-    className?: string;
-    layout?: MasonrySkeletonNode;
-    ratios?: number[];
-    heightsPx?: number[];
-    backgroundColor?: string;
-    highlightColor?: string;
-    radius?: SkeletonLength;
-    shimmer?: SkeletonShimmer;
-};
-
-type LoadingOptions = {
-    enabled?: boolean;
-    force?: boolean;
-    renderLoading?: (args: {
-        count: number;
-    }) => React.ReactNode;
-    skeleton?: MasonrySkeletonSpec;
-    timing?: LoadingTimingOptions;
-};
-type IntroOptions = {
-    renderIntro?: (args: {
-        active: boolean;
-        containerProps: React.HTMLAttributes<HTMLDivElement>;
-    }, content: React.ReactNode) => React.ReactNode;
-    staggerMs?: number;
-    durationMs?: number;
-    easing?: string;
-    staggerLimit?: number;
-};
-type FullscreenTrigger = "item" | "media";
-type MasonryLazyLoadOptions = GalleryLazyLoadOptions;
-type MasonryOptions = {
-    columns?: ResponsiveNumber;
-    gap?: ResponsiveNumber;
-    placement?: "balanced" | "roundRobin";
-    fullscreenTrigger?: FullscreenTrigger;
-    estimatedItemHeight?: number;
-    itemWrapClassName?: string;
-    itemWrapStyle?: React.CSSProperties;
-    as?: React.ElementType;
-    rootRef?: React.Ref<HTMLDivElement>;
-    classNames?: {
-        root?: string;
-        column?: string;
-        item?: string;
-    };
-    lazyLoad?: MasonryLazyLoadOptions;
-    loading?: LoadingOptions;
-    intro?: IntroOptions;
-};
-
-export type { IntroOptions as I, LoadingOptions as L, MasonryOptions as M, MasonryLazyLoadOptions as a };

package/dist/types-XEr8LRal.d.mts

@@ -1,65 +0,0 @@
-import { L as LoadingTimingOptions, R as ResponsiveNumber } from './responsive-D_xhZmVI.mjs';
-import { S as SkeletonLayoutRoot, a as SkeletonNode$1, b as SkeletonWrapStyle, c as SkeletonLength, d as SkeletonShimmer, G as GalleryLazyLoadOptions } from './layout-CR6f2aPH.mjs';
-
-type GridSkeletonWrapStyle = SkeletonWrapStyle;
-type SkeletonNode = SkeletonNode$1;
-type GridSkeletonSlot = {
-    item?: SkeletonNode;
-    itemWrapStyle?: GridSkeletonWrapStyle;
-};
-type GridSkeletonLayoutNode = SkeletonLayoutRoot<"grid"> & {
-    slots?: GridSkeletonSlot[];
-};
-type GridSkeletonNode = GridSkeletonLayoutNode | SkeletonNode$1;
-type GridSkeletonSpec = {
-    className?: string;
-    layout?: GridSkeletonNode;
-    backgroundColor?: string;
-    radius?: SkeletonLength;
-    shimmer?: SkeletonShimmer;
-};
-
-type LoadingOptions = {
-    enabled?: boolean;
-    force?: boolean;
-    renderLoading?: (args: {
-        count: number;
-    }) => React.ReactNode;
-    skeleton?: GridSkeletonSpec;
-    timing?: LoadingTimingOptions;
-};
-type IntroOptions = {
-    renderIntro?: (args: {
-        active: boolean;
-        containerProps: React.HTMLAttributes<HTMLDivElement>;
-    }, content: React.ReactNode) => React.ReactNode;
-    staggerMs?: number;
-    durationMs?: number;
-    easing?: string;
-    staggerLimit?: number;
-};
-type FullscreenTrigger = 'item' | 'media';
-type GridLazyLoadOptions = GalleryLazyLoadOptions;
-type GridSpan = number | "full";
-type ResponsiveGridSpan = GridSpan | Record<string, GridSpan>;
-type ResponsiveGridTemplate = string | Record<string, string>;
-type GridItemProps = {
-    span?: ResponsiveGridSpan;
-    className?: string;
-    style?: React.CSSProperties;
-    children?: React.ReactNode;
-};
-type GridOptions = {
-    columns?: ResponsiveNumber;
-    templateColumns?: ResponsiveGridTemplate;
-    minColumnWidth?: number | string;
-    gap?: ResponsiveNumber;
-    rootClassName?: string;
-    itemClassName?: string;
-    fullscreenTrigger?: FullscreenTrigger;
-    lazyLoad?: GridLazyLoadOptions;
-    loading?: LoadingOptions;
-    intro?: IntroOptions;
-};
-
-export type { GridItemProps as G, IntroOptions as I, LoadingOptions as L, ResponsiveGridSpan as R, GridLazyLoadOptions as a, GridOptions as b, GridSpan as c, ResponsiveGridTemplate as d };