infinity-forge 0.54.7 → 0.55.1

package/dist/ui/components/carousel/interfaces.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="react" />
+import { SwiperOptions } from "./swiper/types/index.js";
 export interface CarouselProps<T = any> {
     id: string;
     items: T[];
-    config?: any;
+    config?: SwiperOptions;
     Component: React.ComponentType<T>;
 }

package/dist/ui/components/carousel/swiper/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './shared.js';
+export { default as Swiper } from './swiper-class.js';
+export * from './swiper-events.js';
+export * from './swiper-options.js';
+export * from './modules/public-api';

package/dist/ui/components/carousel/swiper/types/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Swiper = void 0;
+__exportStar(require("./shared.js"), exports);
+var swiper_class_1 = require("./swiper-class.js");
+Object.defineProperty(exports, "Swiper", { enumerable: true, get: function () { return __importDefault(swiper_class_1).default; } });
+__exportStar(require("./swiper-events.js"), exports);
+__exportStar(require("./swiper-options.js"), exports);
+__exportStar(require("./modules/public-api"), exports);
+//# sourceMappingURL=index.js.map

package/dist/ui/components/carousel/swiper/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../src/ui/components/carousel/swiper/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,+CAAmD;AAA1C,uHAAA,OAAO,OAAU;AAC1B,kDAAgC;AAChC,mDAAiC;AACjC,uDAAqC"}

package/dist/ui/components/carousel/swiper/types/shared.d.ts

@@ -0,0 +1,14 @@
+import type { Swiper } from './index.js';
+export interface CSSSelector extends String {
+}
+export type SwiperModule = (options: {
+    params: Swiper['params'];
+    swiper: Swiper;
+    extendParams: (obj: {
+        [name: string]: any;
+    }) => void;
+    on: Swiper['on'];
+    once: Swiper['once'];
+    off: Swiper['off'];
+    emit: Swiper['emit'];
+}) => void;

package/dist/ui/components/carousel/swiper/types/shared.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=shared.js.map

package/dist/ui/components/carousel/swiper/types/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../../../../../src/ui/components/carousel/swiper/types/shared.ts"],"names":[],"mappings":""}

package/dist/ui/components/carousel/swiper/types/swiper-class.d.ts

@@ -0,0 +1,415 @@
+import type { SwiperOptions } from './swiper-options.js';
+import type { CSSSelector, SwiperModule } from './shared.js';
+import type { SwiperEvents } from './swiper-events.js';
+import type { A11yMethods } from './modules/a11y.js';
+import type { AutoplayMethods } from './modules/autoplay.js';
+import type { ControllerMethods } from './modules/controller.js';
+import type { CoverflowEffectMethods } from './modules/effect-coverflow.js';
+import type { CubeEffectMethods } from './modules/effect-cube.js';
+import type { FadeEffectMethods } from './modules/effect-fade.js';
+import type { FlipEffectMethods } from './modules/effect-flip.js';
+import type { CreativeEffectMethods } from './modules/effect-creative.js';
+import type { CardsEffectMethods } from './modules/effect-cards.js';
+import type { HashNavigationMethods } from './modules/hash-navigation.js';
+import type { HistoryMethods } from './modules/history.js';
+import type { KeyboardMethods } from './modules/keyboard.js';
+import type { MousewheelMethods } from './modules/mousewheel.js';
+import type { NavigationMethods } from './modules/navigation.js';
+import type { PaginationMethods } from './modules/pagination.js';
+import type { ParallaxMethods } from './modules/parallax.js';
+import type { ScrollbarMethods } from './modules/scrollbar.js';
+import type { ThumbsMethods } from './modules/thumbs.js';
+import type { VirtualMethods } from './modules/virtual.js';
+import type { ZoomMethods } from './modules/zoom.js';
+import type { FreeModeMethods } from './modules/free-mode.js';
+import type { ManipulationMethods } from './modules/manipulation.js';
+interface SwiperClass<Events> {
+    /** Add event handler */
+    on<E extends keyof Events>(event: E, handler: Events[E]): void;
+    /** Add event handler that will be removed after it was fired */
+    once<E extends keyof Events>(event: E, handler: Events[E]): void;
+    /** Remove event handler */
+    off<E extends keyof Events>(event: E, handler: Events[E]): void;
+    /** Remove all handlers for specified event */
+    off<E extends keyof Events>(event: E): void;
+    /** Fire event on instance */
+    emit<E extends keyof Events>(event: E, ...args: any[]): void;
+}
+interface Swiper extends SwiperClass<SwiperEvents> {
+    /**
+     * Object with passed initialization parameters
+     */
+    params: SwiperOptions;
+    /**
+     * Object with original initialization parameters
+     */
+    originalParams: SwiperOptions;
+    /**
+     * Slider container HTML element
+     */
+    el: HTMLElement;
+    /**
+     * Wrapper HTML element
+     */
+    wrapperEl: HTMLElement;
+    /**
+     * Array of slides HTML elements. To get specific slide HTMLElement use `swiper.slides[1]`
+     */
+    slides: HTMLElement[];
+    /**
+     * !INTERNAL
+     */
+    loopedSlides: number | null;
+    /**
+     * Width of container
+     */
+    width: number;
+    /**
+     * Height of container
+     */
+    height: number;
+    /**
+     * Current value of wrapper translate
+     */
+    translate: number;
+    /**
+     * Current progress of wrapper translate (from 0 to 1)
+     */
+    progress: number;
+    /**
+     * Index number of currently active slide
+     *
+     * @note Note, that in loop mode active index value will be always shifted on a number of looped slides
+     */
+    activeIndex: number;
+    /**
+     * Index number of currently active slide considering rearranged slides in loop mode
+     */
+    realIndex: number;
+    /**
+     * Index number of previously active slide
+     */
+    previousIndex: number;
+    /**
+     * Index number of current snap in `snapGrid`
+     */
+    snapIndex: number;
+    /**
+     * Slides snap grid
+     */
+    snapGrid: number[];
+    /**
+     * `true` if slider on most "left"/"top" position
+     */
+    isBeginning: boolean;
+    /**
+     * `true` if slider on most "right"/"bottom" position
+     */
+    isEnd: boolean;
+    /**
+     * `true` if slide is "locked" (by `watchOverflow`) and slides can not be, e.g. when amount of slides is less that slides per view
+     */
+    isLocked: boolean;
+    /**
+     * `true` if swiper is in transition
+     */
+    animating: boolean;
+    /**
+     * Object with the following touch event properties:
+     *
+     * - `swiper.touches.startX`
+     * - `swiper.touches.startY`
+     * - `swiper.touches.currentX`
+     * - `swiper.touches.currentY`
+     * - `swiper.touches.diff`
+     */
+    touches: {
+        startX: number;
+        startY: number;
+        currentX: number;
+        currentY: number;
+        diff: number;
+    };
+    /**
+     * Index number of last clicked slide
+     */
+    clickedIndex: number;
+    /**
+     * Link to last clicked slide (HTMLElement)
+     */
+    clickedSlide: HTMLElement;
+    /**
+     * Disable / enable ability to slide to the next slides by assigning `false` / `true` to this property
+     */
+    allowSlideNext: boolean;
+    /**
+     * Disable / enable ability to slide to the previous slides by assigning `false` / `true` to this property
+     */
+    allowSlidePrev: boolean;
+    /**
+     * Disable / enable ability move slider by grabbing it with mouse or by touching it with finger (on touch screens) by assigning `false` / `true` to this property
+     */
+    allowTouchMove: boolean;
+    /**
+     * Direction of sliding
+     */
+    swipeDirection: 'prev' | 'next';
+    /**
+     * !INTERNAL
+     */
+    rtlTranslate: boolean;
+    /**
+     * Disable Swiper (if it was enabled). When Swiper is disabled, it will hide all navigation elements and won't respond to any events and interactions
+     *
+     */
+    disable(): void;
+    /**
+     * Enable Swiper (if it was disabled)
+     *
+     */
+    enable(): void;
+    /**
+     * Set Swiper translate progress (from 0 to 1). Where 0 - its initial position (offset) on first slide, and 1 - its maximum position (offset) on last slide
+     *
+     * @param progress Swiper translate progress (from 0 to 1).
+     * @param speed Transition duration (in ms).
+     */
+    setProgress(progress: number, speed?: number): void;
+    /**
+     * Run transition to next slide.
+     *
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slideNext(speed?: number, runCallbacks?: boolean): boolean;
+    /**
+     * Run transition to previous slide.
+     *
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slidePrev(speed?: number, runCallbacks?: boolean): boolean;
+    /**
+     * Run transition to the slide with index number equal to 'index' parameter for the
+     *  duration equal to 'speed' parameter.
+     *
+     * @param index Index number of slide.
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slideTo(index: number, speed?: number, runCallbacks?: boolean): boolean;
+    /**
+     * Does the same as .slideTo but for the case when used with enabled loop. So this
+     * method will slide to slides with realIndex matching to passed index
+     *
+     * @param index Index number of slide.
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slideToLoop(index: number, speed?: number, runCallbacks?: boolean): Swiper;
+    /**
+     * Reset swiper position to currently active slide for the duration equal to 'speed'
+     * parameter.
+     *
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slideReset(speed?: number, runCallbacks?: boolean): boolean;
+    /**
+     * Reset swiper position to closest slide/snap point for the duration equal to 'speed' parameter.
+     *
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slideToClosest(speed?: number, runCallbacks?: boolean): boolean;
+    /**
+     * Get dynamically calculated amount of slides per view, useful only when slidesPerView set to `auto`
+     *
+     */
+    slidesPerViewDynamic(): number;
+    /**
+     * Force swiper to update its height (when autoHeight enabled) for the duration equal to
+     * 'speed' parameter
+     *
+     * @param speed Transition duration (in ms).
+     */
+    updateAutoHeight(speed?: number): void;
+    /**
+     * You should call it after you add/remove slides
+     * manually, or after you hide/show it, or do any
+     * custom DOM modifications with Swiper
+     * This method also includes subcall of the following
+     * methods which you can use separately:
+     */
+    update(): void;
+    /**
+     * recalculate size of swiper container
+     */
+    updateSize(): void;
+    /**
+     * recalculate number of slides and their offsets. Useful after you add/remove slides with JavaScript
+     */
+    updateSlides(): void;
+    /**
+     * recalculate swiper progress
+     */
+    updateProgress(): void;
+    /**
+     * update active/prev/next classes on slides and bullets
+     */
+    updateSlidesClasses(): void;
+    /**
+     * Changes slider direction from horizontal to vertical and back.
+     *
+     * @param direction New direction. If not specified, then will automatically changed to opposite direction
+     * @param needUpdate Will call swiper.update(). Default true
+     */
+    changeDirection(direction?: 'horizontal' | 'vertical', needUpdate?: boolean): void;
+    /**
+     * Changes slider language
+     *
+     * @param direction New direction. Should be `rtl` or `ltr`
+     */
+    changeLanguageDirection(direction: 'rtl' | 'ltr'): void;
+    /**
+     * Detach all events listeners
+     */
+    detachEvents(): void;
+    /**
+     * Attach all events listeners again
+     */
+    attachEvents(): void;
+    /**
+     * !INTERNAL
+     */
+    loopCreate(): void;
+    /**
+     * !INTERNAL
+     */
+    loopDestroy(): void;
+    /**
+     * Initialize slider
+     */
+    init(el?: HTMLElement): Swiper;
+    /**
+     * Destroy slider instance and detach all events listeners
+     *
+     * @param deleteInstance Set it to false (by default it is true) to not to delete Swiper instance
+     * @param cleanStyles Set it to true (by default it is true) and all custom styles will be removed from slides, wrapper and container.
+     * Useful if you need to destroy Swiper and to init again with new options or in different direction
+     */
+    destroy(deleteInstance?: boolean, cleanStyles?: boolean): void;
+    /**
+     * Set custom css3 transform's translate value for swiper wrapper
+     */
+    setTranslate(translate: any): void;
+    /**
+     * Get current value of swiper wrapper css3 transform translate
+     */
+    getTranslate(): any;
+    /**
+     * Animate custom css3 transform's translate value for swiper wrapper
+     *
+     * @param translate Translate value (in px)
+     * @param speed Transition duration (in ms)
+     * @param runCallbacks Set it to false (by default it is true) and transition will not produce  transition events
+     * @param translateBounds Set it to false (by default it is true) and transition value can extend beyond min and max translate
+     *
+     */
+    translateTo(translate: number, speed: number, runCallbacks?: boolean, translateBounds?: boolean): any;
+    /**
+     * Unset grab cursor
+     */
+    unsetGrabCursor(): void;
+    /**
+     * Set grab cursor
+     */
+    setGrabCursor(): void;
+    /**
+     * Add event listener that will be fired on all events
+     */
+    onAny(handler: (eventName: string, ...args: any[]) => void): void;
+    /**
+     * Remove event listener that will be fired on all events
+     */
+    offAny(handler: (eventName: string, ...args: any[]) => void): void;
+    /**
+     * !INTERNAL
+     */
+    isHorizontal(): boolean;
+    /**
+     * !INTERNAL
+     */
+    getBreakpoint(breakpoints: SwiperOptions['breakpoints']): string;
+    /**
+     * !INTERNAL
+     */
+    setBreakpoint(): void;
+    /**
+     * !INTERNAL
+     */
+    currentBreakpoint: any;
+    /**
+     * !INTERNAL
+     */
+    destroyed: boolean;
+    /**
+     * !INTERNAL
+     */
+    modules: Array<SwiperModule>;
+    a11y: A11yMethods;
+    autoplay: AutoplayMethods;
+    controller: ControllerMethods;
+    coverflowEffect: CoverflowEffectMethods;
+    cubeEffect: CubeEffectMethods;
+    fadeEffect: FadeEffectMethods;
+    flipEffect: FlipEffectMethods;
+    creativeEffect: CreativeEffectMethods;
+    cardsEffect: CardsEffectMethods;
+    hashNavigation: HashNavigationMethods;
+    history: HistoryMethods;
+    keyboard: KeyboardMethods;
+    mousewheel: MousewheelMethods;
+    navigation: NavigationMethods;
+    pagination: PaginationMethods;
+    parallax: ParallaxMethods;
+    scrollbar: ScrollbarMethods;
+    thumbs: ThumbsMethods;
+    virtual: VirtualMethods;
+    zoom: ZoomMethods;
+    freeMode: FreeModeMethods;
+}
+interface Swiper extends ManipulationMethods {
+}
+declare class Swiper implements Swiper {
+    /**
+     * Constructs a new Swiper instance.
+     *
+     * @param container Where Swiper applies to.
+     * @param options   Instance options.
+     */
+    constructor(container: CSSSelector | HTMLElement, options?: SwiperOptions);
+    /**
+     * Installs modules on Swiper in runtime.
+     */
+    static use(modules: SwiperModule[]): void;
+    /**
+     * Swiper default options
+     */
+    static defaults: SwiperOptions;
+    /**
+     * Extend global Swiper defaults
+     */
+    static extendDefaults(options: SwiperOptions): void;
+    /**
+     * Object with global Swiper extended options
+     */
+    static extendedDefaults: SwiperOptions;
+}
+export default Swiper;

package/dist/ui/components/carousel/swiper/types/swiper-class.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Swiper;
+//# sourceMappingURL=swiper-class.js.map

package/dist/ui/components/carousel/swiper/types/swiper-class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swiper-class.js","sourceRoot":"","sources":["../../../../../../src/ui/components/carousel/swiper/types/swiper-class.ts"],"names":[],"mappings":";;AA2eA,kBAAe,MAAM,CAAC"}

package/dist/ui/components/carousel/swiper/types/swiper-events.d.ts

@@ -0,0 +1,162 @@
+import type { SwiperOptions } from './swiper-options.js';
+import type Swiper from './swiper-class.js';
+import type { A11yEvents } from './modules/a11y';
+import type { AutoplayEvents } from './modules/autoplay';
+import type { ControllerEvents } from './modules/controller';
+import type { CoverflowEffectEvents } from './modules/effect-coverflow';
+import type { CubeEffectEvents } from './modules/effect-cube';
+import type { FadeEffectEvents } from './modules/effect-fade';
+import type { FlipEffectEvents } from './modules/effect-flip';
+import type { CreativeEffectEvents } from './modules/effect-creative';
+import type { CardsEffectEvents } from './modules/effect-cards';
+import type { HashNavigationEvents } from './modules/hash-navigation';
+export type SwiperEvents = {
+    init: (swiper: Swiper) => any;
+    beforeDestroy: (swiper: Swiper) => void;
+    slidesUpdated: (swiper: Swiper) => void;
+    slideChange: (swiper: Swiper) => void;
+    slideChangeTransitionStart: (swiper: Swiper) => void;
+    slideChangeTransitionEnd: (swiper: Swiper) => void;
+    slideNextTransitionStart: (swiper: Swiper) => void;
+    slideNextTransitionEnd: (swiper: Swiper) => void;
+    slidePrevTransitionStart: (swiper: Swiper) => void;
+    slidePrevTransitionEnd: (swiper: Swiper) => void;
+    transitionStart: (swiper: Swiper) => void;
+    transitionEnd: (swiper: Swiper) => void;
+    touchStart: (swiper: Swiper, event: MouseEvent | TouchEvent | PointerEvent) => void;
+    touchMove: (swiper: Swiper, event: MouseEvent | TouchEvent | PointerEvent) => void;
+    touchMoveOpposite: (swiper: Swiper, event: MouseEvent | TouchEvent | PointerEvent) => void;
+    sliderMove: (swiper: Swiper, event: MouseEvent | TouchEvent | PointerEvent) => void;
+    touchEnd: (swiper: Swiper, event: MouseEvent | TouchEvent | PointerEvent) => void;
+    click: (swiper: Swiper, event: MouseEvent | TouchEvent | PointerEvent) => void;
+    tap: (swiper: Swiper, event: MouseEvent | TouchEvent | PointerEvent) => void;
+    doubleTap: (swiper: Swiper, event: MouseEvent | TouchEvent | PointerEvent) => void;
+    /**
+     * Event will be fired when Swiper progress is changed, as an arguments it receives progress that is always from 0 to 1
+     */
+    progress: (swiper: Swiper, progress: number) => void;
+    /**
+     * Event will be fired when Swiper reach its beginning (initial position)
+     */
+    reachBeginning: (swiper: Swiper) => void;
+    /**
+     * Event will be fired when Swiper reach last slide
+     */
+    reachEnd: (swiper: Swiper) => void;
+    /**
+     * Event will be fired when Swiper goes to beginning or end position
+     */
+    toEdge: (swiper: Swiper) => void;
+    /**
+     * Event will be fired when Swiper goes from beginning or end position
+     */
+    fromEdge: (swiper: Swiper) => void;
+    /**
+     * Event will be fired when swiper's wrapper change its position. Receives current translate value as an arguments
+     */
+    setTranslate: (swiper: Swiper, translate: number) => void;
+    /**
+     * Event will be fired everytime when swiper starts animation. Receives current transition duration (in ms) as an arguments
+     */
+    setTransition: (swiper: Swiper, transition: number) => void;
+    /**
+     * Event will be fired on window resize right before swiper's onresize manipulation
+     */
+    resize: (swiper: Swiper) => void;
+    /**
+     * Event will be fired if observer is enabled and it detects DOM mutations
+     */
+    observerUpdate: (swiper: Swiper) => void;
+    /**
+     * Event will be fired right before "loop fix"
+     */
+    beforeLoopFix: (swiper: Swiper) => void;
+    /**
+     * Event will be fired after "loop fix"
+     */
+    loopFix: (swiper: Swiper) => void;
+    breakpoint: (swiper: Swiper, breakpointParams: SwiperOptions) => void;
+    _beforeBreakpoint?: (swiper: Swiper, breakpointParams: SwiperOptions) => void;
+    _containerClasses?: (swiper: Swiper, classNames: string) => void;
+    _slideClass?: (swiper: Swiper, slideEl: HTMLElement, classNames: string) => void;
+    _slideClasses?: (swiper: Swiper, slides: {
+        slideEl: HTMLElement;
+        classNames: string;
+        index: number;
+    }[]) => void;
+    _swiper?: (swiper: Swiper) => void;
+    _freeModeNoMomentumRelease?: (swiper: Swiper) => void;
+    activeIndexChange: (swiper: Swiper) => void;
+    snapIndexChange: (swiper: Swiper) => void;
+    realIndexChange: (swiper: Swiper) => void;
+    afterInit: (swiper: Swiper) => void;
+    beforeInit: (swiper: Swiper) => void;
+    /**
+     * Event will fired before resize handler
+     */
+    beforeResize: (swiper: Swiper) => void;
+    /**
+     * Event will fired before slide change transition start
+     */
+    beforeSlideChangeStart: (swiper: Swiper) => void;
+    /**
+     * Event will fired before transition start
+     */
+    beforeTransitionStart: (swiper: Swiper, speed: number, internal: any) => void;
+    /**
+     * Event will fired on direction change
+     */
+    changeDirection: (swiper: Swiper) => void;
+    /**
+     * Event will be fired when user double click/tap on Swiper
+     */
+    doubleClick: (swiper: Swiper, event: MouseEvent | TouchEvent | PointerEvent) => void;
+    /**
+     * Event will be fired on swiper destroy
+     */
+    destroy: (swiper: Swiper) => void;
+    /**
+     * Event will be fired on momentum bounce
+     */
+    momentumBounce: (swiper: Swiper) => void;
+    /**
+     * Event will be fired on orientation change (e.g. landscape -> portrait)
+     */
+    orientationchange: (swiper: Swiper) => void;
+    /**
+     * Event will be fired in the beginning of animation of resetting slide to current one
+     */
+    slideResetTransitionStart: (swiper: Swiper) => void;
+    /**
+     * Event will be fired in the end of animation of resetting slide to current one
+     */
+    slideResetTransitionEnd: (swiper: Swiper) => void;
+    /**
+     * Event will be fired with first touch/drag move
+     */
+    sliderFirstMove: (swiper: Swiper, event: TouchEvent) => void;
+    /**
+     * Event will be fired when number of slides has changed
+     */
+    slidesLengthChange: (swiper: Swiper) => void;
+    /**
+     * Event will be fired when slides grid has changed
+     */
+    slidesGridLengthChange: (swiper: Swiper) => void;
+    /**
+     * Event will be fired when snap grid has changed
+     */
+    snapGridLengthChange: (swiper: Swiper) => void;
+    /**
+     * Event will be fired after swiper.update() call
+     */
+    update: (swiper: Swiper) => void;
+    /**
+     * Event will be fired when swiper is locked (when `watchOverflow` enabled)
+     */
+    lock: (swiper: Swiper) => void;
+    /**
+     * Event will be fired when swiper is unlocked (when `watchOverflow` enabled)
+     */
+    unlock: (swiper: Swiper) => void;
+} & A11yEvents & AutoplayEvents & ControllerEvents & CoverflowEffectEvents & CubeEffectEvents & FadeEffectEvents & FlipEffectEvents & CreativeEffectEvents & CardsEffectEvents & HashNavigationEvents;

package/dist/ui/components/carousel/swiper/types/swiper-events.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=swiper-events.js.map

package/dist/ui/components/carousel/swiper/types/swiper-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swiper-events.js","sourceRoot":"","sources":["../../../../../../src/ui/components/carousel/swiper/types/swiper-events.ts"],"names":[],"mappings":""}