pratcice/node_modules/vue3-carousel/dist/carousel.d.ts

import * as vue from 'vue';
import { Ref, VNode } from 'vue';

interface Data$1 {
  [key: string]: unknown
}

declare const SNAP_ALIGN_OPTIONS = ['center', 'start', 'end', 'center-even', 'center-odd']
declare const BREAKPOINT_MODE_OPTIONS = ['viewport', 'carousel']
declare const DIR_OPTIONS = [
  'ltr',
  'left-to-right',
  'rtl',
  'right-to-left',
  'ttb',
  'top-to-bottom',
  'btt',
  'bottom-to-top',
]
declare const I18N_DEFAULT_CONFIG = {
  ariaNextSlide: 'Navigate to next slide',
  ariaPreviousSlide: 'Navigate to previous slide',
  ariaNavigateToSlide: 'Navigate to slide {slideNumber}',
  ariaGallery: 'Gallery',
  itemXofY: 'Item {currentSlide} of {slidesCount}',
  iconArrowUp: 'Arrow pointing upwards',
  iconArrowDown: 'Arrow pointing downwards',
  iconArrowRight: 'Arrow pointing to the right',
  iconArrowLeft: 'Arrow pointing to the left',
}

type Breakpoints = { [key: number]: Partial<CarouselConfig> }

type SnapAlign = (typeof SNAP_ALIGN_OPTIONS)[number]

type Dir = (typeof DIR_OPTIONS)[number]

type BreakpointMode = (typeof BREAKPOINT_MODE_OPTIONS)[number]

type I18nKeys = keyof typeof I18N_DEFAULT_CONFIG
interface CarouselConfig {
  enabled: boolean
  itemsToShow: number
  itemsToScroll: number
  modelValue?: number
  transition?: number
  gap: number
  autoplay?: number
  snapAlign: SnapAlign
  wrapAround?: boolean
  pauseAutoplayOnHover?: boolean
  mouseDrag?: boolean
  touchDrag?: boolean
  dir?: Dir
  breakpointMode?: string
  breakpoints?: Breakpoints
  height: string | number
  i18n: { [key in I18nKeys]?: string }
}

interface CarouselNav {
  slideTo: (index: number) => void
  next: () => void
  prev: () => void
}

interface CarouselData {
  config: CarouselConfig
  slidesCount: Ref<number>
  slideSize: Ref<number>
  currentSlide: Ref<number>
  maxSlide: Ref<number>
  minSlide: Ref<number>
  middleSlide: Ref<number>
}

interface CarouselMethods extends CarouselNav {
  updateBreakpointsConfig: () => void
  updateSlidesData: () => void
  updateSlideSize: () => void
  restartCarousel: () => void
}
interface CarouselExposed extends CarouselMethods {
  nav: CarouselNav
  data: CarouselData
}

declare const _default$1: vue.DefineComponent<{
    enabled: boolean;
    itemsToShow: number;
    itemsToScroll: number;
    modelValue?: number | undefined;
    transition?: number | undefined;
    gap: number;
    autoplay?: number | undefined;
    snapAlign: SnapAlign;
    wrapAround?: boolean | undefined;
    pauseAutoplayOnHover?: boolean | undefined;
    mouseDrag?: boolean | undefined;
    touchDrag?: boolean | undefined;
    dir?: Dir | undefined;
    breakpointMode?: string | undefined;
    breakpoints?: Breakpoints | undefined;
    height: string | number;
    i18n: { [key in I18nKeys]?: string; };
}, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, "drag" | "init" | "slide-start" | "loop" | "update:modelValue" | "slide-end" | "before-init", vue.PublicProps, Readonly<{
    enabled: boolean;
    itemsToShow: number;
    itemsToScroll: number;
    modelValue?: number | undefined;
    transition?: number | undefined;
    gap: number;
    autoplay?: number | undefined;
    snapAlign: SnapAlign;
    wrapAround?: boolean | undefined;
    pauseAutoplayOnHover?: boolean | undefined;
    mouseDrag?: boolean | undefined;
    touchDrag?: boolean | undefined;
    dir?: Dir | undefined;
    breakpointMode?: string | undefined;
    breakpoints?: Breakpoints | undefined;
    height: string | number;
    i18n: { [key in I18nKeys]?: string; };
}> & Readonly<{}>, {
    snapAlign: string;
    enabled: boolean;
    itemsToShow: number;
    itemsToScroll: number;
    modelValue: number;
    transition: number;
    gap: number;
    autoplay: number;
    wrapAround: boolean;
    pauseAutoplayOnHover: boolean;
    mouseDrag: boolean;
    touchDrag: boolean;
    dir: string;
    breakpointMode: string;
    breakpoints: Record<string, any>;
    height: string | number;
    i18n: Record<string, any>;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

interface Data {
    [key: string]: unknown;
}

declare const Icon: {
    (props: Data): vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | undefined;
    props: {
        name: StringConstructor;
        title: StringConstructor;
    };
};

declare const Navigation: (props: any, { slots, attrs }: any) => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[];

declare const Pagination: () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>;

declare const _default: vue.DefineComponent<vue.ExtractPropTypes<{
    index: {
        type: NumberConstructor;
        default: number;
    };
    isClone: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    index: {
        type: NumberConstructor;
        default: number;
    };
    isClone: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{}>, {
    index: number;
    isClone: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

export { type BreakpointMode, type Breakpoints, _default$1 as Carousel, type CarouselConfig, type CarouselData, type CarouselExposed, type CarouselMethods, type CarouselNav, type Data$1 as Data, type Dir, type I18nKeys, Icon, Navigation, Pagination, _default as Slide, type SnapAlign };