react-motion-gallery 2.0.6 → 2.0.8

package/dist/slider.d.mts

@@ -0,0 +1,80 @@
+import * as React from 'react';
+import { a as BreakpointMap } from './responsive-CvE5dTnP.mjs';
+import { S as SliderOptions, a as SliderHandle } from './types-Dqm2ynv2.mjs';
+export { R as ResponsiveHeightRule } from './types-Dqm2ynv2.mjs';
+import { S as SliderIndexChannel } from './sliderSub-DNikv2lm.mjs';
+export { I as IndexMode, c as createSliderIndexChannel } from './sliderSub-DNikv2lm.mjs';
+import './elements-Bd1vm4Uk.mjs';
+
+declare const Slider: React.ForwardRefExoticComponent<SliderOptions & {
+    children?: React.ReactNode;
+    breakpoints?: BreakpointMap;
+    expandableImageRefs?: React.RefObject<Array<HTMLImageElement | null>>;
+    indexChannel?: SliderIndexChannel;
+} & React.RefAttributes<SliderHandle>>;
+
+declare const DEFAULT_SLIDER: {
+    readonly layout: {
+        readonly gap: 20;
+    };
+    readonly direction: {
+        readonly dir: "ltr";
+        readonly axis: "x";
+    };
+    readonly align: "start";
+    readonly scroll: {
+        readonly groupCells: false;
+        readonly skipSnaps: false;
+        readonly freeScroll: false;
+        readonly loop: false;
+    };
+    readonly lazyLoad: {
+        readonly enabled: false;
+        readonly spinner: true;
+        readonly spinnerClassName: "";
+        readonly spinnerStyle: {};
+    };
+    readonly controls: {
+        readonly arrows: {
+            readonly enabled: true;
+            readonly arrow: {};
+            readonly prev: {};
+            readonly next: {};
+        };
+        readonly dots: {
+            readonly enabled: true;
+            readonly root: {};
+            readonly dot: {};
+        };
+        readonly progress: {
+            readonly enabled: false;
+            readonly root: {};
+            readonly bar: {};
+        };
+        readonly ripple: {
+            readonly enabled: true;
+            readonly className: "";
+        };
+    };
+    readonly auto: {
+        readonly play: {
+            readonly enabled: false;
+            readonly speedMs: 3000;
+            readonly pauseMs: 1000;
+            readonly pauseOnHover: true;
+        };
+        readonly scroll: {
+            readonly enabled: false;
+            readonly speedMs: 3000;
+            readonly pauseMs: 1000;
+            readonly pauseOnHover: true;
+        };
+    };
+    readonly motion: {
+        readonly selectDuration: 25;
+        readonly freeScrollDuration: 43;
+        readonly friction: 0.68;
+    };
+};
+
+export { DEFAULT_SLIDER, Slider, SliderHandle, SliderIndexChannel, SliderOptions, Slider as default };

package/dist/slider.mjs

@@ -0,0 +1 @@
+export{a as DEFAULT_SLIDER,b as Slider,b as default}from'./chunk-KA2TOUNO.mjs';import'./chunk-UYTKRIYQ.mjs';import'./chunk-LPIHQAND.mjs';import'./chunk-JYKEA7LO.mjs';export{a as createSliderIndexChannel}from'./chunk-H4BEIJAD.mjs';import'./chunk-TZGAHWM7.mjs';import'./chunk-ESF6XBYF.mjs';import'./chunk-NKBEYOBF.mjs';import'./chunk-EV6ZK4QI.mjs';import'./chunk-X4HEGEZV.mjs';import'./chunk-LVYED5ZM.mjs';import'./chunk-2AHLR3V4.mjs';

package/dist/sliderSub-DNikv2lm.d.mts

@@ -0,0 +1,76 @@
+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 IndexListener = () => void;
+type IndexEvent = {
+    type: "set";
+    index: number;
+    mode: IndexMode;
+} | {
+    type: "bump";
+    delta: number;
+    mode: IndexMode;
+};
+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;
+    }): void;
+    bump(delta: number, m?: IndexMode, opts?: {
+        silent?: boolean;
+    }): void;
+    subscribe(fn: IndexListener): () => void;
+    onEvent(fn: EventListener): () => void;
+    onBasePointerDown(fn: BasePointerDownListener): () => void;
+    emitBasePointerDown: () => void;
+};
+
+export { type FullscreenOpenRequest as F, type GalleryApi as G, type IndexMode as I, type OpenFullscreenAtArgs as O, type SliderIndexChannel as S, type FullscreenOpenMethod as a, createSliderIndexChannel as c };

package/dist/thumbnails.css

@@ -0,0 +1 @@
+.thumbShell{position:relative}.thumbContentLayer{position:relative;z-index:1}.thumbContentBlocked{pointer-events:none}.thumbLoadingLayer{position:absolute;inset:0;z-index:5;opacity:1;pointer-events:none;transition:opacity .22s ease;will-change:opacity}.thumbLoadingLayerExit{opacity:0}.thumbSkeletonOverlay{position:absolute;inset:0;z-index:5;pointer-events:none;display:flex;align-items:center;justify-content:center}.thumbSkeletonRow{display:flex;width:100%;height:100%}.thumbSkeleton{border-radius:6px;overflow:hidden;position:relative;background:linear-gradient(90deg,var(--rmg-shimmer-c1, #f0f2f5) 25%,var(--rmg-shimmer-c2, #e6e9ef) 37%,var(--rmg-shimmer-c3, #f0f2f5) 63%);background-size:var(--rmg-shimmer-size, 400% 100%);animation:rmgThumbShimmer var(--rmg-shimmer-duration, 1.2s) infinite var(--rmg-shimmer-timing, linear)}@keyframes rmgThumbShimmer{0%{background-position:100% 0}to{background-position:-100% 0}}@media(prefers-reduced-motion:reduce){.thumbLoadingLayer{transition:none}}.thumb{position:relative;overflow:hidden;box-sizing:border-box}.thumb:after{content:"";position:absolute;inset:0;border-radius:inherit;pointer-events:none;box-shadow:0 0 0 2px #111 inset;opacity:0;transition:opacity .12s ease;z-index:1}.thumb[data-active=true]:after{opacity:1}.fadeInStart{opacity:0}.fadeInActive{opacity:1;transition:opacity var(--rmg-intro-duration, .42s) var(--rmg-intro-easing, cubic-bezier(.2,.7,.2,1))}@media(prefers-reduced-motion:reduce){.fadeInActive{transition:none}}.fade_container [data-rmg-thumb-index]>*{opacity:0;transform:translateY(var(--rmg-intro-transform, 10px));transition:opacity var(--rmg-intro-duration, .3s) var(--rmg-intro-easing, cubic-bezier(.2,.7,.2,1)),transform var(--rmg-intro-duration, .3s) var(--rmg-intro-easing, cubic-bezier(.2,.7,.2,1));transition-delay:calc(var(--rmg-intro-index, 0) * var(--rmg-intro-stagger, 40ms));will-change:opacity,transform}.fade_container.fadeInActive [data-rmg-thumb-index]>*{opacity:1;transform:translateY(0)}.ripple{position:absolute;border-radius:50%;transform:scale(0);animation:ripple .6s linear;background-color:#0000004d;pointer-events:none}@keyframes ripple{to{transform:scale(4);opacity:0}}

package/dist/thumbnails.d.mts

@@ -0,0 +1,68 @@
+import * as React from 'react';
+import { S as SliderIndexChannel, I as IndexMode } from './sliderSub-DNikv2lm.mjs';
+import { a as BreakpointMap } from './responsive-CvE5dTnP.mjs';
+import { a as ThumbnailsOptions } from './types-Bi2iBbyG.mjs';
+export { R as ResponsivePosition, e as ThumbnailContainerLayout, c as ThumbnailIntroOptions, d as ThumbnailLayout, b as ThumbnailLoadingOptions, T as ThumbnailPosition, k as ThumbnailsControls, g as ThumbnailsElements, f as ThumbnailsLayout, i as ThumbnailsMotion, j as ThumbnailsRipple, h as ThumbnailsScroll, l as ThumbnailsTransitions } from './types-Bi2iBbyG.mjs';
+import './elements-Bd1vm4Uk.mjs';
+
+type Props = {
+    options?: ThumbnailsOptions;
+    children?: React.ReactNode;
+    indexChannel?: SliderIndexChannel;
+    breakpoints?: BreakpointMap;
+    onThumbnailClick?: (index: number) => void;
+    onReadyChange?: (ready: boolean) => void;
+    direction?: "ltr" | "rtl";
+};
+declare const ThumbnailSlider: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLDivElement>>;
+
+type SliderIndexEvent = {
+    type: "set";
+    index: number;
+    mode: IndexMode;
+} | {
+    type: "bump";
+    delta: number;
+    mode: IndexMode;
+};
+type SliderIndexChannelLike = {
+    get: () => {
+        index: number;
+        mode: IndexMode;
+    };
+    set: (index: number, mode?: IndexMode, opts?: {
+        silent?: boolean;
+    }) => void;
+    bump: (delta: number, mode?: IndexMode, opts?: {
+        silent?: boolean;
+    }) => void;
+    onEvent?: (fn: (event: SliderIndexEvent) => void) => () => void;
+    subscribe?: (fn: () => void) => () => void;
+    onBasePointerDown?: (fn: () => void) => () => void;
+    emitBasePointerDown?: () => void;
+};
+type CreateThumbnailSyncBridgeArgs = {
+    localChannel: SliderIndexChannelLike;
+    externalChannel?: SliderIndexChannelLike | null;
+    clampIndex?: (index: number) => number;
+};
+type ThumbnailSyncBridge = {
+    start: () => () => void;
+    stop: () => void;
+    publishThumbnailClick: (index: number, mode?: IndexMode) => void;
+};
+/**
+ * Bridge local thumbnails index state with an optional external slider channel.
+ *
+ * Intended integration pattern:
+ * - Create/own a local channel for ThumbnailSlider internals.
+ * - Create this bridge with { localChannel, externalChannel }.
+ * - Call bridge.start() inside an effect and clean it up on unmount.
+ * - Call bridge.publishThumbnailClick(index) from thumbnail click handler only.
+ * - Keep wheel/drag/arrows local by never publishing them externally.
+ */
+declare function createThumbnailSyncBridge(args: CreateThumbnailSyncBridgeArgs): ThumbnailSyncBridge;
+
+declare const DEFAULT_THUMBNAILS: Required<Pick<ThumbnailsOptions, "layout" | "scroll" | "motion">>;
+
+export { DEFAULT_THUMBNAILS, ThumbnailSlider, type ThumbnailSyncBridge, ThumbnailsOptions, createThumbnailSyncBridge, ThumbnailSlider as default };

package/dist/thumbnails.mjs

@@ -0,0 +1 @@
+export{a as DEFAULT_THUMBNAILS,c as ThumbnailSlider,b as createThumbnailSyncBridge,c as default}from'./chunk-2UHS4WYL.mjs';import'./chunk-P2GQPFSL.mjs';import'./chunk-H4BEIJAD.mjs';import'./chunk-TZGAHWM7.mjs';import'./chunk-ESF6XBYF.mjs';import'./chunk-X4HEGEZV.mjs';import'./chunk-LVYED5ZM.mjs';import'./chunk-2AHLR3V4.mjs';

package/dist/types-Bi2iBbyG.d.mts

@@ -0,0 +1,85 @@
+import * as React from 'react';
+import { R as ResponsiveNumber, a as BreakpointMap } from './responsive-CvE5dTnP.mjs';
+import { E as ElementStyle, A as ArrowRenderArgs } from './elements-Bd1vm4Uk.mjs';
+
+type ThumbnailPosition = "top" | "right" | "bottom" | "left";
+type ResponsivePosition = ThumbnailPosition | Array<ThumbnailPosition> | Record<string, ThumbnailPosition>;
+type ThumbnailLoadingOptions = {
+    enabled?: boolean;
+    force?: boolean;
+    skeletonCount?: ResponsiveNumber;
+    renderLoading?: () => React.ReactNode;
+};
+type ThumbnailIntroOptions = {
+    renderIntro?: (args: {
+        active: boolean;
+        containerProps: React.HTMLAttributes<HTMLDivElement>;
+    }, inner: React.ReactNode) => React.ReactNode;
+    staggerMs?: number;
+    transform?: string;
+    durationMs?: number;
+    easing?: string;
+};
+type ThumbnailLayout = {
+    width?: number | string;
+    height?: number | string;
+};
+type ThumbnailContainerLayout = {
+    width?: number | string;
+    height?: number | string;
+};
+type ThumbnailsLayout = {
+    position?: ResponsivePosition;
+    gap?: number;
+    center?: boolean;
+    thumbnail?: ThumbnailLayout;
+    container?: ThumbnailContainerLayout;
+};
+type ThumbnailsElements = {
+    container?: ElementStyle;
+    thumbnail?: ElementStyle;
+};
+type ThumbnailsScroll = {
+    freeScroll?: boolean;
+    groupCells?: boolean;
+    loop?: boolean;
+    skipSnaps?: boolean;
+    centerActiveThumb?: boolean;
+};
+type ThumbnailsMotion = {
+    selectDuration?: number;
+    freeScrollDuration?: number;
+    friction?: number;
+};
+type ThumbnailsRipple = {
+    enabled?: boolean;
+    className?: string;
+};
+type ThumbnailsControls = {
+    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;
+    ripple?: ThumbnailsRipple;
+};
+type ThumbnailsTransitions = {
+    loading?: ThumbnailLoadingOptions;
+    intro?: ThumbnailIntroOptions;
+};
+type ThumbnailsOptions = {
+    children?: React.ReactNode;
+    layout?: ThumbnailsLayout;
+    elements?: ThumbnailsElements;
+    scroll?: ThumbnailsScroll;
+    controls?: ThumbnailsControls;
+    motion?: ThumbnailsMotion;
+    transitions?: ThumbnailsTransitions;
+    breakpointMap?: BreakpointMap;
+};
+
+export type { ResponsivePosition as R, ThumbnailPosition as T, ThumbnailsOptions as a, ThumbnailLoadingOptions as b, ThumbnailIntroOptions as c, ThumbnailLayout as d, ThumbnailContainerLayout as e, ThumbnailsLayout as f, ThumbnailsElements as g, ThumbnailsScroll as h, ThumbnailsMotion as i, ThumbnailsRipple as j, ThumbnailsControls as k, ThumbnailsTransitions as l };

package/dist/types-CQ6I3EfZ.d.mts

@@ -0,0 +1,109 @@
+import * as React from 'react';
+import { a as BreakpointMap } from './responsive-CvE5dTnP.mjs';
+import { T as ThumbnailPosition } from './types-Bi2iBbyG.mjs';
+
+type JumpMode = 'instant' | 'animated';
+type FSRequest = {
+    type: 'requestSet';
+    index: number;
+    mode?: JumpMode;
+} | {
+    type: 'requestNext';
+} | {
+    type: 'requestPrev';
+} | {
+    type: 'center';
+};
+type FSEvent = {
+    type: 'internalIndex';
+    index: number;
+} | {
+    type: 'mounted';
+} | {
+    type: 'unmounted';
+};
+type FullscreenSliderSub = {
+    get: () => number;
+    requestSet: (index: number, mode?: JumpMode) => void;
+    requestPrev: () => void;
+    requestNext: () => void;
+    requestCenter: () => void;
+    onEvent: (fn: (evt: FSEvent) => void) => () => void;
+    onRequest: (fn: (req: FSRequest) => void) => () => void;
+    setLocalIndex: (index: number) => void;
+    destroy: () => void;
+    onBasePointerDown: (fn: () => void) => () => void;
+    emitBasePointerDown: () => void;
+};
+
+type ArrowRenderArgs = {
+    ref: React.RefObject<HTMLDivElement | null>;
+    onClick: () => void;
+    hidden: boolean;
+    disabled: boolean;
+    createRipple: (el: HTMLElement) => void;
+    className?: string;
+};
+type FSItem = {
+    thumbSrc: string;
+    alt?: string;
+};
+type FullscreenThumbnailSlotLayout = {
+    position: ThumbnailPosition;
+    className?: string;
+    style?: React.CSSProperties;
+    fadeDurationMs?: number;
+    fadeEasing?: string;
+};
+type FullscreenThumbnailBridge = {
+    mountEl: HTMLDivElement | null;
+    fsSub: FullscreenSliderSub;
+    visible: boolean;
+    invisible: boolean;
+    direction: 'ltr' | 'rtl';
+    registerLayout: (layout: FullscreenThumbnailSlotLayout) => void;
+    clearLayout: () => void;
+};
+type FullscreenThumbnailSliderProps = {
+    bridge: FullscreenThumbnailBridge;
+    items: FSItem[];
+    position: ThumbnailPosition;
+    containerClassName?: string;
+    containerStyle?: React.CSSProperties;
+    thumbnailWidth?: number | string;
+    thumbnailHeight?: number | string;
+    thumbnailsCenter?: boolean;
+    thumbnailsContainerWidth?: number | string;
+    thumbnailsContainerHeight?: number | string;
+    fadeDurationMs?: number;
+    fadeEasing?: string;
+    thumbnailItemClassName?: string;
+    thumbnailItemStyle?: React.CSSProperties;
+    gap?: number;
+    freeScroll?: boolean;
+    groupCells?: boolean;
+    loop?: boolean;
+    axis?: 'x' | 'y';
+    skipSnaps?: boolean;
+    centerActiveThumb?: boolean;
+    selectDuration?: number;
+    freeScrollDuration?: number;
+    sliderFriction?: number;
+    breakpointMap?: BreakpointMap;
+    rippleEnabled?: boolean;
+    rippleClassName?: string;
+    showArrows?: boolean;
+    arrowStyles?: React.CSSProperties;
+    arrowClassName?: string;
+    prevArrowStyles?: React.CSSProperties;
+    prevArrowClassName?: string;
+    nextArrowStyles?: React.CSSProperties;
+    nextArrowClassName?: string;
+    renderArrows?: (args: ArrowRenderArgs & {
+        dir: 'prev' | 'next';
+    }) => React.ReactNode;
+    renderPrevArrow?: (args: ArrowRenderArgs) => React.ReactNode;
+    renderNextArrow?: (args: ArrowRenderArgs) => React.ReactNode;
+};
+
+export type { FSItem as F, FullscreenThumbnailBridge as a, FullscreenThumbnailSliderProps as b, FullscreenThumbnailSlotLayout as c };

package/dist/types-ChjyCquV.d.mts

@@ -0,0 +1,158 @@
+import { E as ElementStyle } from './elements-Bd1vm4Uk.mjs';
+import { M as MediaItem } from './media-moIXOhT1.mjs';
+import * as React$1 from 'react';
+
+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;
+    marginTop?: SkeletonLength;
+    marginRight?: SkeletonLength;
+    marginBottom?: SkeletonLength;
+    marginLeft?: SkeletonLength;
+    alignSelf?: React$1.CSSProperties["alignSelf"];
+    aspectRatio?: number | string;
+};
+type SkeletonContainerStyle = {
+    gap?: SkeletonLength;
+    padding?: SkeletonLength;
+    align?: React$1.CSSProperties["alignItems"];
+    justify?: React$1.CSSProperties["justifyContent"];
+    wrap?: boolean;
+    width?: SkeletonLength;
+    maxWidth?: SkeletonLength;
+};
+type SkeletonContainerStyleResponsive = SkeletonContainerStyle | Record<string, SkeletonContainerStyle>;
+type SkeletonNode = {
+    kind: "stack" | "row" | "col";
+    style?: SkeletonContainerStyleResponsive;
+    children: SkeletonNode[];
+} | {
+    kind: "rect" | "square" | "circle";
+    style?: SkeletonBaseStyle;
+    shimmer?: SkeletonShimmer;
+} | {
+    kind: "media";
+    count: number;
+    direction?: "row" | "col";
+    style?: SkeletonContainerStyleResponsive;
+    tile?: {
+        shape?: "rect" | "square" | "circle";
+        style?: SkeletonBaseStyle;
+        shimmer?: SkeletonShimmer;
+    };
+} | {
+    kind: "text";
+    fontSize: number;
+    lineHeight: number;
+    lines?: number;
+    style?: SkeletonBaseStyle;
+    shimmer?: SkeletonShimmer;
+};
+type EntrySkeletonSpec = {
+    layout?: SkeletonNode;
+    variant?: "solid";
+    minHeight?: SkeletonLength;
+    defaults?: {
+        backgroundColor?: string;
+        highlightColor?: string;
+        radius?: SkeletonLength;
+        shimmer?: SkeletonShimmer;
+    };
+};
+
+type EntryItem = {
+    media?: MediaItem[];
+    [key: string]: any;
+};
+type EntryMediaRenderArgs = {
+    entry: EntryItem;
+    entryIndex: number;
+    media: MediaItem;
+    mediaIndex: number;
+};
+type MediaEntryLink = {
+    entryIndex: number;
+    mediaIndex: number;
+};
+type EntryOverlayRenderArgs = {
+    entry: EntryItem;
+    entryIndex: number;
+    mediaIndex: number | null;
+    link: MediaEntryLink | null;
+    opacity: number;
+    fsIndex: number;
+    style: React.CSSProperties;
+    containerProps: React.HTMLAttributes<HTMLDivElement>;
+};
+type EntryMediaLayout = "slider" | "grid" | "masonry";
+type EntryCardRenderArgs = {
+    entry: EntryItem;
+    entryIndex: number;
+    media: React.ReactNode;
+};
+type EntrySkeletonResolverArgs = {
+    entry: EntryItem;
+    entryIndex: number;
+};
+type EntriesLoadingOptions = {
+    enabled?: boolean;
+    force?: boolean;
+    skeleton?: EntrySkeletonSpec | ((args: EntrySkeletonResolverArgs) => EntrySkeletonSpec | null | undefined);
+    minHeight?: SkeletonLength;
+    nearMargin?: string;
+    viewMargin?: string;
+    threshold?: number;
+    waitForDecode?: boolean;
+    decodeTimeoutMs?: number;
+    skeletonWrap?: ElementStyle;
+};
+type IntroOptions = {
+    renderIntro?: (args: {
+        active: boolean;
+        containerProps: React.HTMLAttributes<HTMLDivElement>;
+    }, content: React.ReactNode) => React.ReactNode;
+    staggerMs?: number;
+    durationMs?: number;
+    easing?: string;
+    staggerLimit?: number;
+};
+type EntrySkeletonRenderArgs = {
+    entry: EntryItem;
+    entryIndex: number;
+};
+type EntriesOptions = {
+    items?: EntryItem[];
+    mediaLayout?: EntryMediaLayout;
+    render?: {
+        card?: (args: EntryCardRenderArgs) => React.ReactNode;
+        media?: (args: EntryMediaRenderArgs) => React.ReactNode;
+        overlay?: (args: EntryOverlayRenderArgs) => React.ReactNode;
+        skeleton?: (args: EntrySkeletonRenderArgs) => React.ReactNode;
+    };
+    overlay?: ElementStyle;
+    loading?: EntriesLoadingOptions;
+    intro?: IntroOptions;
+    entryList?: ElementStyle;
+    entryRow?: ElementStyle;
+};
+type SlideOwner = {
+    entryIndex: number;
+};
+
+export type { EntriesOptions as E, IntroOptions as I, MediaEntryLink as M, SlideOwner as S, EntryItem as a, EntryMediaRenderArgs as b, EntryOverlayRenderArgs as c, EntryMediaLayout as d, EntryCardRenderArgs as e, EntrySkeletonResolverArgs as f, EntriesLoadingOptions as g, EntrySkeletonRenderArgs as h };