react-chrono

Package Overview

Dependencies

Maintainers

Versions

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

react-chrono - npm Package Compare versions

Comparing version 2.2.2 to 2.2.3

dist/components/timeline-elements/timeline-card-content/details-text.d.ts

dist/components/timeline-elements/timeline-card-content/text-or-content.d.ts

dist/components/timeline-elements/timeline-outline/timeline-outline-item-list.d.ts

dist/components/common/styles/index.d.ts

		@@ -1,1 +0,1 @@
		export declare const ScrollBar: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
		export declare const ScrollBar: import("styled-components").RuleSet<object>;

dist/components/timeline-elements/memoized/memoized-model.d.ts

		import { Theme } from '@models/Theme';
		import React, { ReactNode } from 'react';
		import React, { ForwardRefExoticComponent, ReactNode } from 'react';
		import { TextOrContentModel } from '../timeline-card-content/text-or-content';
		type common = {
		@@ -35,3 +36,3 @@ classString?: string;
		show?: boolean;
		text: ReactNode;
		text: ForwardRefExoticComponent<TextOrContentModel>;
		textOverlay?: boolean;
		@@ -38,0 +39,0 @@ theme?: Theme;

dist/components/timeline-elements/timeline-card-content/card-animations.styles.d.ts

		@@ -1,4 +0,4 @@
		export declare const reveal: import("styled-components").Keyframes;
		export declare const slideInFromTop: import("styled-components").Keyframes;
		export declare const slideInFromLeft: import("styled-components").Keyframes;
		export declare const slideFromRight: import("styled-components").Keyframes;
		export declare const reveal: import("styled-components/dist/models/Keyframes").default;
		export declare const slideInFromTop: import("styled-components/dist/models/Keyframes").default;
		export declare const slideInFromLeft: import("styled-components/dist/models/Keyframes").default;
		export declare const slideFromRight: import("styled-components/dist/models/Keyframes").default;

dist/components/timeline-elements/timeline-card-content/content-footer.d.ts

		import { FunctionComponent } from 'react';
		import { ContentFooterProps } from './header-footer.model';
		/**
		* This component is used to render the footer of the timeline card.
		* It renders the read more/less button, progress bar and triangle icon.
		* The read more/less button is only rendered if the content is large.
		* The progress bar and triangle icon are only rendered if the card is in slideshow mode.
		* ContentFooter
		*
		* A functional component that renders the footer of the timeline card.
		* It displays the read more/less button, progress bar, and triangle icon.
		* The read more/less button appears only if the content is large.
		* The progress bar and triangle icon are displayed only if the card is in slideshow mode.
		*
		* @property {boolean} showProgressBar - Determines if progress bar should be displayed.
		* @property {Function} onExpand - Function called when expanding content.
		* @property {string} triangleDir - Direction of the triangle icon.
		* @property {boolean} showMore - Determines if 'read more' should be displayed.
		* @property {boolean} textContentIsLarge - Determines if text content is large.
		* @property {boolean} showReadMore - Determines if 'read more' button should be displayed.
		* @property {number} remainInterval - Remaining interval for progress bar.
		* @property {boolean} paused - Determines if progress is paused.
		* @property {number} startWidth - Starting width of progress bar.
		* @property {boolean} canShow - Determines if the element can be shown.
		* @property {React.RefObject} progressRef - Ref to the progress bar.
		* @property {boolean} isNested - Determines if component is nested.
		* @property {boolean} isResuming - Determines if slideshow is resuming.
		*
		* @returns {JSX.Element} ContentFooter component.
		*/
		declare const ContentFooter: FunctionComponent<ContentFooterProps>;
		export { ContentFooter };

dist/components/timeline-elements/timeline-card-content/content-header.d.ts

		import { FunctionComponent } from 'react';
		import { ContentHeaderProps } from './header-footer.model';
		/**
		* ContentHeader component
		* This component renders the header of the timeline card including the title and subtitle.
		* It doesn't render the title and subtitle if the card has media.
		* The title and subtitle are memoized to prevent unnecessary re-renders.
		*
		* @property {string} title - The title of the card.
		* @property {string} url - The URL of the card.
		* @property {boolean} media - Indicates whether the card has media or not.
		* @property {string} content - The main content of the card.
		* @returns {JSX.Element} The ContentHeader component.
		*/
		declare const ContentHeader: FunctionComponent<ContentHeaderProps>;
		export { ContentHeader };

596

dist/components/timeline-elements/timeline-card-content/timeline-card-content.styles.d.ts

		@@ -0,5 +1,7 @@
		/// <reference types="react" />
		/// <reference types="react" />
		import { Theme } from '@models/Theme';
		import { TimelineProps } from '@models/TimelineModel';
		type ContentT = Pick<TimelineProps, 'theme' \| 'slideShow' \| 'mode' \| 'borderLessCards'>;
		export declare const TimelineItemContentWrapper: import("styled-components").StyledComponent<"section", any, {
		export declare const TimelineItemContentWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, {
		$active?: boolean;
		@@ -16,5 +18,276 @@ $borderLessCards?: TimelineProps['borderLessCards'];
		$textOverlay?: boolean;
		} & ContentT, never>;
		export declare const TimelineCardHeader: import("styled-components").StyledComponent<"header", any, {}, never>;
		export declare const CardSubTitle: import("styled-components").StyledComponent<"h2", any, {
		} & ContentT>>;
		export declare const TimelineCardHeader: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLElement>;
		key?: import("react").Key;
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "false" \| "true");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "false" \| "true";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "false" \| "true";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "text" \| "search" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "false" \| "true";
		'aria-autocomplete'?: "none" \| "both" \| "inline" \| "list";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "false" \| "true";
		'aria-checked'?: boolean \| "mixed" \| "false" \| "true";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "page" \| "false" \| "true" \| "step" \| "location" \| "date" \| "time";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "false" \| "true";
		'aria-dropeffect'?: "none" \| "copy" \| "move" \| "link" \| "execute" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "false" \| "true";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "false" \| "true";
		'aria-haspopup'?: boolean \| "listbox" \| "grid" \| "menu" \| "false" \| "true" \| "dialog" \| "tree";
		'aria-hidden'?: boolean \| "false" \| "true";
		'aria-invalid'?: boolean \| "false" \| "true" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "false" \| "true";
		'aria-multiline'?: boolean \| "false" \| "true";
		'aria-multiselectable'?: boolean \| "false" \| "true";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "mixed" \| "false" \| "true";
		'aria-readonly'?: boolean \| "false" \| "true";
		'aria-relevant'?: "all" \| "text" \| "additions" \| "additions removals" \| "additions text" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "false" \| "true";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "false" \| "true";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLElement>;
		onFocus?: import("react").FocusEventHandler<HTMLElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLElement>;
		onBlur?: import("react").FocusEventHandler<HTMLElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLElement>;
		onChange?: import("react").FormEventHandler<HTMLElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLElement>;
		onInput?: import("react").FormEventHandler<HTMLElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLElement>;
		onReset?: import("react").FormEventHandler<HTMLElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLElement>;
		onSubmit?: import("react").FormEventHandler<HTMLElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLElement>;
		onInvalid?: import("react").FormEventHandler<HTMLElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLElement>;
		onLoad?: import("react").ReactEventHandler<HTMLElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLElement>;
		onError?: import("react").ReactEventHandler<HTMLElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLElement>;
		onAbort?: import("react").ReactEventHandler<HTMLElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLElement>;
		onEnded?: import("react").ReactEventHandler<HTMLElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLElement>;
		onPause?: import("react").ReactEventHandler<HTMLElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLElement>;
		onPlay?: import("react").ReactEventHandler<HTMLElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLElement>;
		onProgress?: import("react").ReactEventHandler<HTMLElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLElement>;
		onResize?: import("react").ReactEventHandler<HTMLElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLElement>;
		onStalled?: import("react").ReactEventHandler<HTMLElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLElement>;
		onClick?: import("react").MouseEventHandler<HTMLElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLElement>;
		onDrag?: import("react").DragEventHandler<HTMLElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLElement>;
		onDragExit?: import("react").DragEventHandler<HTMLElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLElement>;
		onDragOver?: import("react").DragEventHandler<HTMLElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLElement>;
		onDragStart?: import("react").DragEventHandler<HTMLElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLElement>;
		onDrop?: import("react").DragEventHandler<HTMLElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLElement>;
		onSelect?: import("react").ReactEventHandler<HTMLElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLElement>;
		onScroll?: import("react").UIEventHandler<HTMLElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLElement>;
		onWheel?: import("react").WheelEventHandler<HTMLElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLElement>;
		}>;
		export declare const CardSubTitle: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {
		$fontSize?: string;
		@@ -24,4 +297,4 @@ $padding?: boolean;
		theme?: Theme;
		}, never>;
		export declare const CardTitle: import("styled-components").StyledComponent<"h1", any, {
		}>>;
		export declare const CardTitle: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {
		$fontSize: string;
		@@ -31,12 +304,291 @@ $padding?: boolean;
		theme: Theme;
		}, never>;
		export declare const CardTitleAnchor: import("styled-components").StyledComponent<"a", any, {}, never>;
		export declare const TimelineContentDetails: import("styled-components").StyledComponent<"p", any, {
		}>>;
		export declare const CardTitleAnchor: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLAnchorElement>;
		key?: import("react").Key;
		download?: any;
		href?: string;
		hrefLang?: string;
		media?: string;
		ping?: string;
		target?: import("react").HTMLAttributeAnchorTarget;
		type?: string;
		referrerPolicy?: import("react").HTMLAttributeReferrerPolicy;
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "false" \| "true");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "false" \| "true";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "false" \| "true";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "text" \| "search" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "false" \| "true";
		'aria-autocomplete'?: "none" \| "both" \| "inline" \| "list";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "false" \| "true";
		'aria-checked'?: boolean \| "mixed" \| "false" \| "true";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "page" \| "false" \| "true" \| "step" \| "location" \| "date" \| "time";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "false" \| "true";
		'aria-dropeffect'?: "none" \| "copy" \| "move" \| "link" \| "execute" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "false" \| "true";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "false" \| "true";
		'aria-haspopup'?: boolean \| "listbox" \| "grid" \| "menu" \| "false" \| "true" \| "dialog" \| "tree";
		'aria-hidden'?: boolean \| "false" \| "true";
		'aria-invalid'?: boolean \| "false" \| "true" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "false" \| "true";
		'aria-multiline'?: boolean \| "false" \| "true";
		'aria-multiselectable'?: boolean \| "false" \| "true";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "mixed" \| "false" \| "true";
		'aria-readonly'?: boolean \| "false" \| "true";
		'aria-relevant'?: "all" \| "text" \| "additions" \| "additions removals" \| "additions text" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "false" \| "true";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "false" \| "true";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLAnchorElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLAnchorElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLAnchorElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLAnchorElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLAnchorElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLAnchorElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLAnchorElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLAnchorElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLAnchorElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLAnchorElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLAnchorElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLAnchorElement>;
		onFocus?: import("react").FocusEventHandler<HTMLAnchorElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLAnchorElement>;
		onBlur?: import("react").FocusEventHandler<HTMLAnchorElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLAnchorElement>;
		onChange?: import("react").FormEventHandler<HTMLAnchorElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLAnchorElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLAnchorElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLAnchorElement>;
		onInput?: import("react").FormEventHandler<HTMLAnchorElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLAnchorElement>;
		onReset?: import("react").FormEventHandler<HTMLAnchorElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLAnchorElement>;
		onSubmit?: import("react").FormEventHandler<HTMLAnchorElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLAnchorElement>;
		onInvalid?: import("react").FormEventHandler<HTMLAnchorElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLAnchorElement>;
		onLoad?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onError?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLAnchorElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLAnchorElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLAnchorElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLAnchorElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLAnchorElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLAnchorElement>;
		onAbort?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onEnded?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onPause?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onPlay?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onProgress?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onResize?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onStalled?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onClick?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onDrag?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragExit?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragOver?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragStart?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDrop?: import("react").DragEventHandler<HTMLAnchorElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLAnchorElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLAnchorElement>;
		onSelect?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLAnchorElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLAnchorElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLAnchorElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLAnchorElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLAnchorElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLAnchorElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLAnchorElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLAnchorElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLAnchorElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLAnchorElement>;
		onScroll?: import("react").UIEventHandler<HTMLAnchorElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLAnchorElement>;
		onWheel?: import("react").WheelEventHandler<HTMLAnchorElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLAnchorElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLAnchorElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLAnchorElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLAnchorElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLAnchorElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLAnchorElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLAnchorElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLAnchorElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLAnchorElement>;
		}>;
		export declare const TimelineContentDetails: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, {
		theme?: Theme;
		}, never>;
		export declare const TimelineSubContent: import("styled-components").StyledComponent<"span", any, {
		}>>;
		export declare const TimelineSubContent: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
		fontSize?: string;
		theme?: Theme;
		}, never>;
		export declare const TimelineContentDetailsWrapper: import("styled-components").StyledComponent<"div", any, {
		}>>;
		export declare const TimelineContentDetailsWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$borderLess?: boolean;
		@@ -53,8 +605,8 @@ $cardHeight?: number \| null;
		theme?: Theme;
		}, never>;
		export declare const ShowMore: import("styled-components").StyledComponent<"span", any, {
		}>>;
		export declare const ShowMore: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
		show?: 'true' \| 'false';
		theme?: Theme;
		}, never>;
		export declare const SlideShowProgressBar: import("styled-components").StyledComponent<"span", any, {
		}>>;
		export declare const SlideShowProgressBar: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
		$color?: string;
		@@ -65,11 +617,11 @@ $duration?: number;
		$startWidth?: number;
		}, never>;
		export declare const ChevronIconWrapper: import("styled-components").StyledComponent<"span", any, {
		}>>;
		export declare const ChevronIconWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
		collapsed?: 'true' \| 'false';
		}, never>;
		export declare const TriangleIconWrapper: import("styled-components").StyledComponent<"span", any, {
		}>>;
		export declare const TriangleIconWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
		dir?: string;
		offset?: number;
		theme?: Theme;
		}, never>;
		}>>;
		export {};

283

dist/components/timeline-elements/timeline-card-media/timeline-card-media-buttons.d.ts

		@@ -0,9 +1,282 @@
		/// <reference types="react" />
		/// <reference types="react" />
		import { Theme } from '@models/Theme';
		export declare const ExpandButton: import("styled-components").StyledComponent<"button", any, {
		export declare const ExpandButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
		theme: Theme;
		}, never>;
		export declare const ShowHideTextButton: import("styled-components").StyledComponent<"button", any, {
		}>>;
		export declare const ShowHideTextButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
		showText?: boolean;
		theme: Theme;
		}, never>;
		export declare const ButtonWrapper: import("styled-components").StyledComponent<"ul", any, {}, never>;
		}>>;
		export declare const ButtonWrapper: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLUListElement>;
		key?: import("react").Key;
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "false" \| "true");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "false" \| "true";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "false" \| "true";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "text" \| "search" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "false" \| "true";
		'aria-autocomplete'?: "none" \| "both" \| "inline" \| "list";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "false" \| "true";
		'aria-checked'?: boolean \| "mixed" \| "false" \| "true";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "page" \| "false" \| "true" \| "step" \| "location" \| "date" \| "time";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "false" \| "true";
		'aria-dropeffect'?: "none" \| "copy" \| "move" \| "link" \| "execute" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "false" \| "true";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "false" \| "true";
		'aria-haspopup'?: boolean \| "listbox" \| "grid" \| "menu" \| "false" \| "true" \| "dialog" \| "tree";
		'aria-hidden'?: boolean \| "false" \| "true";
		'aria-invalid'?: boolean \| "false" \| "true" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "false" \| "true";
		'aria-multiline'?: boolean \| "false" \| "true";
		'aria-multiselectable'?: boolean \| "false" \| "true";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "mixed" \| "false" \| "true";
		'aria-readonly'?: boolean \| "false" \| "true";
		'aria-relevant'?: "all" \| "text" \| "additions" \| "additions removals" \| "additions text" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "false" \| "true";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "false" \| "true";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLUListElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLUListElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLUListElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLUListElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLUListElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLUListElement>;
		onFocus?: import("react").FocusEventHandler<HTMLUListElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLUListElement>;
		onBlur?: import("react").FocusEventHandler<HTMLUListElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLUListElement>;
		onChange?: import("react").FormEventHandler<HTMLUListElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLUListElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onInput?: import("react").FormEventHandler<HTMLUListElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onReset?: import("react").FormEventHandler<HTMLUListElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onSubmit?: import("react").FormEventHandler<HTMLUListElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onInvalid?: import("react").FormEventHandler<HTMLUListElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onLoad?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onError?: import("react").ReactEventHandler<HTMLUListElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onAbort?: import("react").ReactEventHandler<HTMLUListElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLUListElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLUListElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLUListElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLUListElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLUListElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onEnded?: import("react").ReactEventHandler<HTMLUListElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onPause?: import("react").ReactEventHandler<HTMLUListElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onPlay?: import("react").ReactEventHandler<HTMLUListElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLUListElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onProgress?: import("react").ReactEventHandler<HTMLUListElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLUListElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onResize?: import("react").ReactEventHandler<HTMLUListElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLUListElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLUListElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onStalled?: import("react").ReactEventHandler<HTMLUListElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLUListElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLUListElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLUListElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLUListElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLUListElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onClick?: import("react").MouseEventHandler<HTMLUListElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLUListElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLUListElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onDrag?: import("react").DragEventHandler<HTMLUListElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLUListElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLUListElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragExit?: import("react").DragEventHandler<HTMLUListElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLUListElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragOver?: import("react").DragEventHandler<HTMLUListElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragStart?: import("react").DragEventHandler<HTMLUListElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDrop?: import("react").DragEventHandler<HTMLUListElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onSelect?: import("react").ReactEventHandler<HTMLUListElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLUListElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onScroll?: import("react").UIEventHandler<HTMLUListElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLUListElement>;
		onWheel?: import("react").WheelEventHandler<HTMLUListElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLUListElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLUListElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLUListElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLUListElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLUListElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLUListElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLUListElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLUListElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLUListElement>;
		}>;

863

dist/components/timeline-elements/timeline-card-media/timeline-card-media.styles.d.ts

		@@ -0,5 +1,7 @@
		/// <reference types="react" />
		/// <reference types="react" />
		import { Theme } from '@models/Theme';
		import { TimelineMode } from '@models/TimelineModel';
		export declare const linearGradient: import("styled-components").FlattenSimpleInterpolation;
		export declare const MediaWrapper: import("styled-components").StyledComponent<"div", any, {
		export declare const linearGradient: import("styled-components").RuleSet<object>;
		export declare const MediaWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$active?: boolean;
		@@ -13,4 +15,4 @@ $cardHeight?: number;
		theme?: Theme;
		}, never>;
		export declare const CardImage: import("styled-components").StyledComponent<"img", any, {
		}>>;
		export declare const CardImage: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, {
		$enableBorderRadius?: boolean;
		@@ -21,7 +23,7 @@ $visible?: boolean;
		mode?: TimelineMode;
		}, never>;
		export declare const CardVideo: import("styled-components").StyledComponent<"video", any, {
		}>>;
		export declare const CardVideo: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, {
		height?: number;
		}, never>;
		export declare const MediaDetailsWrapper: import("styled-components").StyledComponent<"div", any, {
		}>>;
		export declare const MediaDetailsWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$absolutePosition?: boolean;
		@@ -36,6 +38,564 @@ $borderLessCard?: boolean;
		theme?: Theme;
		}, never>;
		export declare const ErrorMessage: import("styled-components").StyledComponent<"span", any, {}, never>;
		export declare const IFrameVideo: import("styled-components").StyledComponent<"iframe", any, {}, never>;
		export declare const DetailsTextWrapper: import("styled-components").StyledComponent<"div", any, {
		}>>;
		export declare const ErrorMessage: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLSpanElement>;
		key?: import("react").Key;
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "false" \| "true");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "false" \| "true";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "false" \| "true";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "text" \| "search" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "false" \| "true";
		'aria-autocomplete'?: "none" \| "both" \| "inline" \| "list";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "false" \| "true";
		'aria-checked'?: boolean \| "mixed" \| "false" \| "true";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "page" \| "false" \| "true" \| "step" \| "location" \| "date" \| "time";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "false" \| "true";
		'aria-dropeffect'?: "none" \| "copy" \| "move" \| "link" \| "execute" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "false" \| "true";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "false" \| "true";
		'aria-haspopup'?: boolean \| "listbox" \| "grid" \| "menu" \| "false" \| "true" \| "dialog" \| "tree";
		'aria-hidden'?: boolean \| "false" \| "true";
		'aria-invalid'?: boolean \| "false" \| "true" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "false" \| "true";
		'aria-multiline'?: boolean \| "false" \| "true";
		'aria-multiselectable'?: boolean \| "false" \| "true";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "mixed" \| "false" \| "true";
		'aria-readonly'?: boolean \| "false" \| "true";
		'aria-relevant'?: "all" \| "text" \| "additions" \| "additions removals" \| "additions text" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "false" \| "true";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "false" \| "true";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLSpanElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLSpanElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLSpanElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLSpanElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLSpanElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLSpanElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLSpanElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLSpanElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLSpanElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLSpanElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLSpanElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLSpanElement>;
		onFocus?: import("react").FocusEventHandler<HTMLSpanElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLSpanElement>;
		onBlur?: import("react").FocusEventHandler<HTMLSpanElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLSpanElement>;
		onChange?: import("react").FormEventHandler<HTMLSpanElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLSpanElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLSpanElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLSpanElement>;
		onInput?: import("react").FormEventHandler<HTMLSpanElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLSpanElement>;
		onReset?: import("react").FormEventHandler<HTMLSpanElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLSpanElement>;
		onSubmit?: import("react").FormEventHandler<HTMLSpanElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLSpanElement>;
		onInvalid?: import("react").FormEventHandler<HTMLSpanElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLSpanElement>;
		onLoad?: import("react").ReactEventHandler<HTMLSpanElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onError?: import("react").ReactEventHandler<HTMLSpanElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLSpanElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLSpanElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLSpanElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLSpanElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLSpanElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLSpanElement>;
		onAbort?: import("react").ReactEventHandler<HTMLSpanElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLSpanElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLSpanElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLSpanElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLSpanElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLSpanElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onEnded?: import("react").ReactEventHandler<HTMLSpanElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLSpanElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLSpanElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLSpanElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onPause?: import("react").ReactEventHandler<HTMLSpanElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onPlay?: import("react").ReactEventHandler<HTMLSpanElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLSpanElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onProgress?: import("react").ReactEventHandler<HTMLSpanElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLSpanElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onResize?: import("react").ReactEventHandler<HTMLSpanElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLSpanElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLSpanElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onStalled?: import("react").ReactEventHandler<HTMLSpanElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLSpanElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLSpanElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLSpanElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLSpanElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLSpanElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLSpanElement>;
		onClick?: import("react").MouseEventHandler<HTMLSpanElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLSpanElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLSpanElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLSpanElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLSpanElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLSpanElement>;
		onDrag?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragExit?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragOver?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragStart?: import("react").DragEventHandler<HTMLSpanElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLSpanElement>;
		onDrop?: import("react").DragEventHandler<HTMLSpanElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLSpanElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLSpanElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLSpanElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLSpanElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLSpanElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLSpanElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLSpanElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLSpanElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLSpanElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLSpanElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLSpanElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLSpanElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLSpanElement>;
		onSelect?: import("react").ReactEventHandler<HTMLSpanElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLSpanElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLSpanElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLSpanElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLSpanElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLSpanElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLSpanElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLSpanElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLSpanElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLSpanElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLSpanElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLSpanElement>;
		onScroll?: import("react").UIEventHandler<HTMLSpanElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLSpanElement>;
		onWheel?: import("react").WheelEventHandler<HTMLSpanElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLSpanElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLSpanElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLSpanElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLSpanElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLSpanElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLSpanElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLSpanElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLSpanElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLSpanElement>;
		}>;
		export declare const IFrameVideo: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLIFrameElement>;
		key?: import("react").Key;
		allow?: string;
		allowFullScreen?: boolean;
		allowTransparency?: boolean;
		frameBorder?: string \| number;
		height?: string \| number;
		loading?: "eager" \| "lazy";
		marginHeight?: number;
		marginWidth?: number;
		name?: string;
		referrerPolicy?: import("react").HTMLAttributeReferrerPolicy;
		sandbox?: string;
		scrolling?: string;
		seamless?: boolean;
		src?: string;
		srcDoc?: string;
		width?: string \| number;
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "false" \| "true");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "false" \| "true";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "false" \| "true";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "text" \| "search" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "false" \| "true";
		'aria-autocomplete'?: "none" \| "both" \| "inline" \| "list";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "false" \| "true";
		'aria-checked'?: boolean \| "mixed" \| "false" \| "true";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "page" \| "false" \| "true" \| "step" \| "location" \| "date" \| "time";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "false" \| "true";
		'aria-dropeffect'?: "none" \| "copy" \| "move" \| "link" \| "execute" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "false" \| "true";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "false" \| "true";
		'aria-haspopup'?: boolean \| "listbox" \| "grid" \| "menu" \| "false" \| "true" \| "dialog" \| "tree";
		'aria-hidden'?: boolean \| "false" \| "true";
		'aria-invalid'?: boolean \| "false" \| "true" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "false" \| "true";
		'aria-multiline'?: boolean \| "false" \| "true";
		'aria-multiselectable'?: boolean \| "false" \| "true";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "mixed" \| "false" \| "true";
		'aria-readonly'?: boolean \| "false" \| "true";
		'aria-relevant'?: "all" \| "text" \| "additions" \| "additions removals" \| "additions text" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "false" \| "true";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "false" \| "true";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLIFrameElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLIFrameElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLIFrameElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLIFrameElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLIFrameElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLIFrameElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLIFrameElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLIFrameElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLIFrameElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLIFrameElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLIFrameElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLIFrameElement>;
		onFocus?: import("react").FocusEventHandler<HTMLIFrameElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLIFrameElement>;
		onBlur?: import("react").FocusEventHandler<HTMLIFrameElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLIFrameElement>;
		onChange?: import("react").FormEventHandler<HTMLIFrameElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLIFrameElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLIFrameElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLIFrameElement>;
		onInput?: import("react").FormEventHandler<HTMLIFrameElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLIFrameElement>;
		onReset?: import("react").FormEventHandler<HTMLIFrameElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLIFrameElement>;
		onSubmit?: import("react").FormEventHandler<HTMLIFrameElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLIFrameElement>;
		onInvalid?: import("react").FormEventHandler<HTMLIFrameElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLIFrameElement>;
		onLoad?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onError?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLIFrameElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLIFrameElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLIFrameElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLIFrameElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLIFrameElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLIFrameElement>;
		onAbort?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onEnded?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onPause?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onPlay?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onProgress?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onResize?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onStalled?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onClick?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onDrag?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragExit?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragOver?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragStart?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDrop?: import("react").DragEventHandler<HTMLIFrameElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLIFrameElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLIFrameElement>;
		onSelect?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLIFrameElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLIFrameElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLIFrameElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLIFrameElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLIFrameElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLIFrameElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLIFrameElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLIFrameElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLIFrameElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLIFrameElement>;
		onScroll?: import("react").UIEventHandler<HTMLIFrameElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLIFrameElement>;
		onWheel?: import("react").WheelEventHandler<HTMLIFrameElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLIFrameElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLIFrameElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLIFrameElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLIFrameElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLIFrameElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLIFrameElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLIFrameElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLIFrameElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLIFrameElement>;
		}>;
		export declare const DetailsTextWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$expandFull?: boolean;
		@@ -45,6 +605,277 @@ $show?: boolean;
		theme?: Theme;
		}, never>;
		export declare const CardMediaHeader: import("styled-components").StyledComponent<"div", any, {}, never>;
		export declare const ImageWrapper: import("styled-components").StyledComponent<"div", any, {
		}>>;
		export declare const CardMediaHeader: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLDivElement>;
		key?: import("react").Key;
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "false" \| "true");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "false" \| "true";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "false" \| "true";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "text" \| "search" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "false" \| "true";
		'aria-autocomplete'?: "none" \| "both" \| "inline" \| "list";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "false" \| "true";
		'aria-checked'?: boolean \| "mixed" \| "false" \| "true";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "page" \| "false" \| "true" \| "step" \| "location" \| "date" \| "time";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "false" \| "true";
		'aria-dropeffect'?: "none" \| "copy" \| "move" \| "link" \| "execute" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "false" \| "true";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "false" \| "true";
		'aria-haspopup'?: boolean \| "listbox" \| "grid" \| "menu" \| "false" \| "true" \| "dialog" \| "tree";
		'aria-hidden'?: boolean \| "false" \| "true";
		'aria-invalid'?: boolean \| "false" \| "true" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "false" \| "true";
		'aria-multiline'?: boolean \| "false" \| "true";
		'aria-multiselectable'?: boolean \| "false" \| "true";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "mixed" \| "false" \| "true";
		'aria-readonly'?: boolean \| "false" \| "true";
		'aria-relevant'?: "all" \| "text" \| "additions" \| "additions removals" \| "additions text" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "false" \| "true";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "false" \| "true";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onFocus?: import("react").FocusEventHandler<HTMLDivElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLDivElement>;
		onBlur?: import("react").FocusEventHandler<HTMLDivElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLDivElement>;
		onChange?: import("react").FormEventHandler<HTMLDivElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLDivElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onInput?: import("react").FormEventHandler<HTMLDivElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onReset?: import("react").FormEventHandler<HTMLDivElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onSubmit?: import("react").FormEventHandler<HTMLDivElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onInvalid?: import("react").FormEventHandler<HTMLDivElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onLoad?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onError?: import("react").ReactEventHandler<HTMLDivElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onAbort?: import("react").ReactEventHandler<HTMLDivElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLDivElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLDivElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEnded?: import("react").ReactEventHandler<HTMLDivElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPause?: import("react").ReactEventHandler<HTMLDivElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlay?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onProgress?: import("react").ReactEventHandler<HTMLDivElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onResize?: import("react").ReactEventHandler<HTMLDivElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onStalled?: import("react").ReactEventHandler<HTMLDivElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLDivElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLDivElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLDivElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLDivElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onDrag?: import("react").DragEventHandler<HTMLDivElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragExit?: import("react").DragEventHandler<HTMLDivElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLDivElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragOver?: import("react").DragEventHandler<HTMLDivElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragStart?: import("react").DragEventHandler<HTMLDivElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDrop?: import("react").DragEventHandler<HTMLDivElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onSelect?: import("react").ReactEventHandler<HTMLDivElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onScroll?: import("react").UIEventHandler<HTMLDivElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLDivElement>;
		onWheel?: import("react").WheelEventHandler<HTMLDivElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLDivElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLDivElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDivElement>;
		}>;
		export declare const ImageWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		height?: number;
		}, never>;
		}>>;

dist/components/timeline-elements/timeline-control/timeline-control.d.ts

		import { TimelineControlModel } from '@models/TimelineControlModel';
		import React from 'react';
		/**
		* TimelineControl component
		* Provides navigation controls for a timeline, including next, previous, first, last, and slideshow buttons.
		* Optionally supports flipping the layout and dark mode toggle.
		*
		* @property {function} onNext - Function to go to the next item.
		* @property {function} onPrevious - Function to go to the previous item.
		* @property {function} onFirst - Function to jump to the first item.
		* @property {function} onLast - Function to jump to the last item.
		* @property {boolean} disableLeft - Whether to disable the left navigation buttons.
		* @property {boolean} disableRight - Whether to disable the right navigation buttons.
		* @property {boolean} slideShowRunning - Whether the slideshow is currently running.
		* @property {function} onReplay - Function to restart the slideshow.
		* @property {boolean} slideShowEnabled - Whether the slideshow feature is enabled.
		* @property {function} onToggleDarkMode - Function to toggle dark mode (if enabled).
		* @property {boolean} isDark - Whether dark mode is currently active.
		* @property {function} onPaused - Function to pause the slideshow (if running).
		* @returns {JSX.Element} The TimelineControl component.
		*/
		declare const TimelineControl: React.FunctionComponent<TimelineControlModel>;
		export default TimelineControl;

859

dist/components/timeline-elements/timeline-control/timeline-control.styles.d.ts

		@@ -0,23 +1,856 @@
		/// <reference types="react" />
		/// <reference types="react" />
		import { Theme } from '@models/Theme';
		import { TimelineMode } from '@models/TimelineModel';
		export declare const TimelineNavWrapper: import("styled-components").StyledComponent<"ul", any, {
		export declare const TimelineNavWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, {
		theme?: Theme;
		}, never>;
		export declare const TimelineNavItem: import("styled-components").StyledComponent<"li", any, {
		}>>;
		export declare const TimelineNavItem: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, {
		$disable?: boolean;
		}, never>;
		export declare const TimelineNavButton: import("styled-components").StyledComponent<"button", any, {
		}>>;
		export declare const TimelineNavButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
		mode?: TimelineMode;
		rotate?: 'TRUE' \| 'FALSE';
		theme?: Theme;
		}, never>;
		export declare const TimelineControlContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
		export declare const ControlButton: import("styled-components").StyledComponent<"button", any, {
		}>>;
		export declare const TimelineControlContainer: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLDivElement>;
		key?: import("react").Key;
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "true" \| "false");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "true" \| "false";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "true" \| "false";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "search" \| "text" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "true" \| "false";
		'aria-autocomplete'?: "none" \| "list" \| "inline" \| "both";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "true" \| "false";
		'aria-checked'?: boolean \| "true" \| "false" \| "mixed";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "time" \| "true" \| "false" \| "page" \| "step" \| "location" \| "date";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "true" \| "false";
		'aria-dropeffect'?: "none" \| "link" \| "copy" \| "execute" \| "move" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "true" \| "false";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "true" \| "false";
		'aria-haspopup'?: boolean \| "dialog" \| "menu" \| "true" \| "false" \| "grid" \| "listbox" \| "tree";
		'aria-hidden'?: boolean \| "true" \| "false";
		'aria-invalid'?: boolean \| "true" \| "false" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "true" \| "false";
		'aria-multiline'?: boolean \| "true" \| "false";
		'aria-multiselectable'?: boolean \| "true" \| "false";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "true" \| "false" \| "mixed";
		'aria-readonly'?: boolean \| "true" \| "false";
		'aria-relevant'?: "text" \| "additions" \| "additions removals" \| "additions text" \| "all" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "true" \| "false";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "true" \| "false";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onFocus?: import("react").FocusEventHandler<HTMLDivElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLDivElement>;
		onBlur?: import("react").FocusEventHandler<HTMLDivElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLDivElement>;
		onChange?: import("react").FormEventHandler<HTMLDivElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLDivElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onInput?: import("react").FormEventHandler<HTMLDivElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onReset?: import("react").FormEventHandler<HTMLDivElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onSubmit?: import("react").FormEventHandler<HTMLDivElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onInvalid?: import("react").FormEventHandler<HTMLDivElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onLoad?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onError?: import("react").ReactEventHandler<HTMLDivElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onAbort?: import("react").ReactEventHandler<HTMLDivElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLDivElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLDivElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEnded?: import("react").ReactEventHandler<HTMLDivElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPause?: import("react").ReactEventHandler<HTMLDivElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlay?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onProgress?: import("react").ReactEventHandler<HTMLDivElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onResize?: import("react").ReactEventHandler<HTMLDivElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onStalled?: import("react").ReactEventHandler<HTMLDivElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLDivElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLDivElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLDivElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLDivElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onDrag?: import("react").DragEventHandler<HTMLDivElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragExit?: import("react").DragEventHandler<HTMLDivElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLDivElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragOver?: import("react").DragEventHandler<HTMLDivElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragStart?: import("react").DragEventHandler<HTMLDivElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDrop?: import("react").DragEventHandler<HTMLDivElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onSelect?: import("react").ReactEventHandler<HTMLDivElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onScroll?: import("react").UIEventHandler<HTMLDivElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLDivElement>;
		onWheel?: import("react").WheelEventHandler<HTMLDivElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLDivElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLDivElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDivElement>;
		}>;
		export declare const ControlButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
		theme?: Theme;
		}, never>;
		export declare const MediaToggle: import("styled-components").StyledComponent<"button", any, {
		}>>;
		export declare const MediaToggle: import("styled-components").IStyledComponent<"web", {
		theme?: Theme;
		}, never>;
		export declare const ReplayWrapper: import("styled-components").StyledComponent<"button", any, {
		key?: import("react").Key;
		value?: string \| number \| readonly string[];
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "true" \| "false");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "true" \| "false";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "true" \| "false";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "search" \| "text" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "true" \| "false";
		'aria-autocomplete'?: "none" \| "list" \| "inline" \| "both";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "true" \| "false";
		'aria-checked'?: boolean \| "true" \| "false" \| "mixed";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "time" \| "true" \| "false" \| "page" \| "step" \| "location" \| "date";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "true" \| "false";
		'aria-dropeffect'?: "none" \| "link" \| "copy" \| "execute" \| "move" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "true" \| "false";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "true" \| "false";
		'aria-haspopup'?: boolean \| "dialog" \| "menu" \| "true" \| "false" \| "grid" \| "listbox" \| "tree";
		'aria-hidden'?: boolean \| "true" \| "false";
		'aria-invalid'?: boolean \| "true" \| "false" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "true" \| "false";
		'aria-multiline'?: boolean \| "true" \| "false";
		'aria-multiselectable'?: boolean \| "true" \| "false";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "true" \| "false" \| "mixed";
		'aria-readonly'?: boolean \| "true" \| "false";
		'aria-relevant'?: "text" \| "additions" \| "additions removals" \| "additions text" \| "all" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "true" \| "false";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "true" \| "false";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onFocus?: import("react").FocusEventHandler<HTMLButtonElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLButtonElement>;
		onBlur?: import("react").FocusEventHandler<HTMLButtonElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLButtonElement>;
		onChange?: import("react").FormEventHandler<HTMLButtonElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLButtonElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onInput?: import("react").FormEventHandler<HTMLButtonElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onReset?: import("react").FormEventHandler<HTMLButtonElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onSubmit?: import("react").FormEventHandler<HTMLButtonElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onInvalid?: import("react").FormEventHandler<HTMLButtonElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onLoad?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onError?: import("react").ReactEventHandler<HTMLButtonElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onAbort?: import("react").ReactEventHandler<HTMLButtonElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLButtonElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLButtonElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLButtonElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEnded?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPause?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPlay?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onProgress?: import("react").ReactEventHandler<HTMLButtonElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLButtonElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onResize?: import("react").ReactEventHandler<HTMLButtonElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onStalled?: import("react").ReactEventHandler<HTMLButtonElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLButtonElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLButtonElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLButtonElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLButtonElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onClick?: import("react").MouseEventHandler<HTMLButtonElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLButtonElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLButtonElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onDrag?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragExit?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragOver?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragStart?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDrop?: import("react").DragEventHandler<HTMLButtonElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onSelect?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLButtonElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onScroll?: import("react").UIEventHandler<HTMLButtonElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLButtonElement>;
		onWheel?: import("react").WheelEventHandler<HTMLButtonElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLButtonElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLButtonElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLButtonElement>;
		disabled?: boolean;
		form?: string;
		formAction?: string;
		formEncType?: string;
		formMethod?: string;
		formNoValidate?: boolean;
		formTarget?: string;
		name?: string;
		type?: "button" \| "submit" \| "reset";
		ref?: import("react").Ref<HTMLButtonElement>;
		}>;
		export declare const ReplayWrapper: import("styled-components").IStyledComponent<"web", {
		theme?: Theme;
		}, never>;
		key?: import("react").Key;
		value?: string \| number \| readonly string[];
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "true" \| "false");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "true" \| "false";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "true" \| "false";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "search" \| "text" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "true" \| "false";
		'aria-autocomplete'?: "none" \| "list" \| "inline" \| "both";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "true" \| "false";
		'aria-checked'?: boolean \| "true" \| "false" \| "mixed";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "time" \| "true" \| "false" \| "page" \| "step" \| "location" \| "date";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "true" \| "false";
		'aria-dropeffect'?: "none" \| "link" \| "copy" \| "execute" \| "move" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "true" \| "false";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "true" \| "false";
		'aria-haspopup'?: boolean \| "dialog" \| "menu" \| "true" \| "false" \| "grid" \| "listbox" \| "tree";
		'aria-hidden'?: boolean \| "true" \| "false";
		'aria-invalid'?: boolean \| "true" \| "false" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "true" \| "false";
		'aria-multiline'?: boolean \| "true" \| "false";
		'aria-multiselectable'?: boolean \| "true" \| "false";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "true" \| "false" \| "mixed";
		'aria-readonly'?: boolean \| "true" \| "false";
		'aria-relevant'?: "text" \| "additions" \| "additions removals" \| "additions text" \| "all" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "true" \| "false";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "true" \| "false";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLButtonElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLButtonElement>;
		onFocus?: import("react").FocusEventHandler<HTMLButtonElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLButtonElement>;
		onBlur?: import("react").FocusEventHandler<HTMLButtonElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLButtonElement>;
		onChange?: import("react").FormEventHandler<HTMLButtonElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLButtonElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onInput?: import("react").FormEventHandler<HTMLButtonElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onReset?: import("react").FormEventHandler<HTMLButtonElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onSubmit?: import("react").FormEventHandler<HTMLButtonElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onInvalid?: import("react").FormEventHandler<HTMLButtonElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLButtonElement>;
		onLoad?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onError?: import("react").ReactEventHandler<HTMLButtonElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLButtonElement>;
		onAbort?: import("react").ReactEventHandler<HTMLButtonElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLButtonElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLButtonElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLButtonElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEnded?: import("react").ReactEventHandler<HTMLButtonElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLButtonElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPause?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPlay?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLButtonElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onProgress?: import("react").ReactEventHandler<HTMLButtonElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLButtonElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onResize?: import("react").ReactEventHandler<HTMLButtonElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onStalled?: import("react").ReactEventHandler<HTMLButtonElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLButtonElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLButtonElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLButtonElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLButtonElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onClick?: import("react").MouseEventHandler<HTMLButtonElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLButtonElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLButtonElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onDrag?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragExit?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragOver?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragStart?: import("react").DragEventHandler<HTMLButtonElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onDrop?: import("react").DragEventHandler<HTMLButtonElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLButtonElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLButtonElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLButtonElement>;
		onSelect?: import("react").ReactEventHandler<HTMLButtonElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLButtonElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLButtonElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLButtonElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLButtonElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLButtonElement>;
		onScroll?: import("react").UIEventHandler<HTMLButtonElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLButtonElement>;
		onWheel?: import("react").WheelEventHandler<HTMLButtonElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLButtonElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLButtonElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLButtonElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLButtonElement>;
		disabled?: boolean;
		form?: string;
		formAction?: string;
		formEncType?: string;
		formMethod?: string;
		formNoValidate?: boolean;
		formTarget?: string;
		name?: string;
		type?: "button" \| "submit" \| "reset";
		ref?: import("react").Ref<HTMLButtonElement>;
		}>;

dist/components/timeline-elements/timeline-item-title/timeline-card-title.d.ts

		import { TitleModel } from '@models/TimelineCardTitleModel';
		import React from 'react';
		/**
		* TimelineItemTitle component
		* This component renders the title of a timeline item and applies appropriate styling based on the given props.
		*
		* @property {string} title - The text of the title.
		* @property {boolean} active - Indicates whether the title is active or not.
		* @property {Theme} theme - The theme object, used for styling.
		* @property {string} align - The alignment of the title.
		* @property {string} classString - Additional CSS classes for the title.
		* @returns {JSX.Element} The TimelineItemTitle component.
		*/
		declare const TimelineItemTitle: React.FunctionComponent<TitleModel>;
		export default TimelineItemTitle;

dist/components/timeline-elements/timeline-item-title/timeline-card-title.styles.d.ts

		@@ -0,3 +1,4 @@
		/// <reference types="react" />
		import { Theme } from '@models/Theme';
		export declare const TitleWrapper: import("styled-components").StyledComponent<"div", any, {
		export declare const TitleWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$fontSize?: string;
		@@ -7,2 +8,2 @@ $hide?: boolean;
		theme?: Theme;
		}, never>;
		}>>;

dist/components/timeline-elements/timeline-outline/timeline-outline.d.ts

		@@ -8,2 +8,8 @@ import { Theme } from '@models/Theme';
		}
		interface TimelineOutlineModel {
		items?: TimelineOutlineItem[];
		mode?: TimelineMode;
		onSelect?: (index: number) => void;
		theme?: Theme;
		}
		export interface TimelineOutlineItem {
		@@ -14,9 +20,15 @@ id?: string;
		}
		export interface TimelineOutlineModel {
		items?: TimelineOutlineItem[];
		mode?: TimelineMode;
		onSelect?: (index: number) => void;
		theme?: Theme;
		}
		declare const TimelineOutline: React.FunctionComponent<TimelineOutlineModel>;
		/**
		* TimelineOutline component
		* This component renders the outline pane of a timeline, including a list of items and corresponding selection functionality.
		* It provides an interface to toggle the outline pane and select items within the timeline.
		* The component leverages memoization to prevent unnecessary re-renders and optimizes the rendering process.
		*
		* @property {TimelineOutlineItem[]} items - The items to be displayed in the outline.
		* @property {TimelineMode} mode - The mode of the timeline which determines the outline position.
		* @property {function} onSelect - The callback to be invoked when an item is selected.
		* @property {Theme} theme - The theme object, used for styling.
		* @returns {JSX.Element} The TimelineOutline component.
		*/
		declare const TimelineOutline: React.FC<TimelineOutlineModel>;
		export { TimelineOutline };

569

dist/components/timeline-elements/timeline-outline/timeline-outline.styles.d.ts

		@@ -0,24 +1,569 @@
		/// <reference types="react" />
		/// <reference types="react" />
		import { Theme } from '@models/Theme';
		import { OutlinePosition } from './timeline-outline';
		export declare const OutlineWrapper: import("styled-components").StyledComponent<"div", any, {
		export declare const OutlineWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		open?: boolean;
		position?: OutlinePosition;
		}, never>;
		export declare const OutlinePane: import("styled-components").StyledComponent<"aside", any, {
		}>>;
		export declare const OutlinePane: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, {
		open?: boolean;
		}, never>;
		export declare const OutlineButton: import("styled-components").StyledComponent<"button", any, {
		}>>;
		export declare const OutlineButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
		open?: boolean;
		position?: OutlinePosition;
		theme?: Theme;
		}, never>;
		export declare const List: import("styled-components").StyledComponent<"ul", any, {}, never>;
		export declare const ListItem: import("styled-components").StyledComponent<"li", any, {}, never>;
		export declare const ListItemName: import("styled-components").StyledComponent<"span", any, {
		}>>;
		export declare const List: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLUListElement>;
		key?: import("react").Key;
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "true" \| "false");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "true" \| "false";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "true" \| "false";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "search" \| "text" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "true" \| "false";
		'aria-autocomplete'?: "none" \| "list" \| "inline" \| "both";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "true" \| "false";
		'aria-checked'?: boolean \| "true" \| "false" \| "mixed";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "true" \| "false" \| "page" \| "step" \| "location" \| "date" \| "time";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "true" \| "false";
		'aria-dropeffect'?: "none" \| "link" \| "copy" \| "execute" \| "move" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "true" \| "false";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "true" \| "false";
		'aria-haspopup'?: boolean \| "true" \| "false" \| "dialog" \| "grid" \| "listbox" \| "menu" \| "tree";
		'aria-hidden'?: boolean \| "true" \| "false";
		'aria-invalid'?: boolean \| "true" \| "false" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "true" \| "false";
		'aria-multiline'?: boolean \| "true" \| "false";
		'aria-multiselectable'?: boolean \| "true" \| "false";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "true" \| "false" \| "mixed";
		'aria-readonly'?: boolean \| "true" \| "false";
		'aria-relevant'?: "text" \| "additions" \| "additions removals" \| "additions text" \| "all" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "true" \| "false";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "true" \| "false";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLUListElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLUListElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLUListElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLUListElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLUListElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLUListElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLUListElement>;
		onFocus?: import("react").FocusEventHandler<HTMLUListElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLUListElement>;
		onBlur?: import("react").FocusEventHandler<HTMLUListElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLUListElement>;
		onChange?: import("react").FormEventHandler<HTMLUListElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLUListElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onInput?: import("react").FormEventHandler<HTMLUListElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onReset?: import("react").FormEventHandler<HTMLUListElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onSubmit?: import("react").FormEventHandler<HTMLUListElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onInvalid?: import("react").FormEventHandler<HTMLUListElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLUListElement>;
		onLoad?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onError?: import("react").ReactEventHandler<HTMLUListElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLUListElement>;
		onAbort?: import("react").ReactEventHandler<HTMLUListElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLUListElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLUListElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLUListElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLUListElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLUListElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onEnded?: import("react").ReactEventHandler<HTMLUListElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLUListElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onPause?: import("react").ReactEventHandler<HTMLUListElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onPlay?: import("react").ReactEventHandler<HTMLUListElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLUListElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onProgress?: import("react").ReactEventHandler<HTMLUListElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLUListElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onResize?: import("react").ReactEventHandler<HTMLUListElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLUListElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLUListElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onStalled?: import("react").ReactEventHandler<HTMLUListElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLUListElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLUListElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLUListElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLUListElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLUListElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onClick?: import("react").MouseEventHandler<HTMLUListElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLUListElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLUListElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onDrag?: import("react").DragEventHandler<HTMLUListElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLUListElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLUListElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragExit?: import("react").DragEventHandler<HTMLUListElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLUListElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragOver?: import("react").DragEventHandler<HTMLUListElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDragStart?: import("react").DragEventHandler<HTMLUListElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onDrop?: import("react").DragEventHandler<HTMLUListElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLUListElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLUListElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLUListElement>;
		onSelect?: import("react").ReactEventHandler<HTMLUListElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLUListElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLUListElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLUListElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLUListElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLUListElement>;
		onScroll?: import("react").UIEventHandler<HTMLUListElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLUListElement>;
		onWheel?: import("react").WheelEventHandler<HTMLUListElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLUListElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLUListElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLUListElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLUListElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLUListElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLUListElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLUListElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLUListElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLUListElement>;
		}>;
		export declare const ListItem: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLLIElement>;
		key?: import("react").Key;
		value?: string \| number \| readonly string[];
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "true" \| "false");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "true" \| "false";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "true" \| "false";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "search" \| "text" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "true" \| "false";
		'aria-autocomplete'?: "none" \| "list" \| "inline" \| "both";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "true" \| "false";
		'aria-checked'?: boolean \| "true" \| "false" \| "mixed";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "true" \| "false" \| "page" \| "step" \| "location" \| "date" \| "time";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "true" \| "false";
		'aria-dropeffect'?: "none" \| "link" \| "copy" \| "execute" \| "move" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "true" \| "false";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "true" \| "false";
		'aria-haspopup'?: boolean \| "true" \| "false" \| "dialog" \| "grid" \| "listbox" \| "menu" \| "tree";
		'aria-hidden'?: boolean \| "true" \| "false";
		'aria-invalid'?: boolean \| "true" \| "false" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "true" \| "false";
		'aria-multiline'?: boolean \| "true" \| "false";
		'aria-multiselectable'?: boolean \| "true" \| "false";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "true" \| "false" \| "mixed";
		'aria-readonly'?: boolean \| "true" \| "false";
		'aria-relevant'?: "text" \| "additions" \| "additions removals" \| "additions text" \| "all" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "true" \| "false";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "true" \| "false";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLLIElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLLIElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLLIElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLLIElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLLIElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLLIElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLLIElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLLIElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLLIElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLLIElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLLIElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLLIElement>;
		onFocus?: import("react").FocusEventHandler<HTMLLIElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLLIElement>;
		onBlur?: import("react").FocusEventHandler<HTMLLIElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLLIElement>;
		onChange?: import("react").FormEventHandler<HTMLLIElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLLIElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLLIElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLLIElement>;
		onInput?: import("react").FormEventHandler<HTMLLIElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLLIElement>;
		onReset?: import("react").FormEventHandler<HTMLLIElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLLIElement>;
		onSubmit?: import("react").FormEventHandler<HTMLLIElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLLIElement>;
		onInvalid?: import("react").FormEventHandler<HTMLLIElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLLIElement>;
		onLoad?: import("react").ReactEventHandler<HTMLLIElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onError?: import("react").ReactEventHandler<HTMLLIElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLLIElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLLIElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLLIElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLLIElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLLIElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLLIElement>;
		onAbort?: import("react").ReactEventHandler<HTMLLIElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLLIElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLLIElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLLIElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLLIElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLLIElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onEnded?: import("react").ReactEventHandler<HTMLLIElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLLIElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLLIElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLLIElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onPause?: import("react").ReactEventHandler<HTMLLIElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onPlay?: import("react").ReactEventHandler<HTMLLIElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLLIElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onProgress?: import("react").ReactEventHandler<HTMLLIElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLLIElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onResize?: import("react").ReactEventHandler<HTMLLIElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLLIElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLLIElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onStalled?: import("react").ReactEventHandler<HTMLLIElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLLIElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLLIElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLLIElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLLIElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLLIElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLLIElement>;
		onClick?: import("react").MouseEventHandler<HTMLLIElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLLIElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLLIElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLLIElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLLIElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLLIElement>;
		onDrag?: import("react").DragEventHandler<HTMLLIElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLLIElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLLIElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLLIElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLLIElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLLIElement>;
		onDragExit?: import("react").DragEventHandler<HTMLLIElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLLIElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLLIElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLLIElement>;
		onDragOver?: import("react").DragEventHandler<HTMLLIElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLLIElement>;
		onDragStart?: import("react").DragEventHandler<HTMLLIElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLLIElement>;
		onDrop?: import("react").DragEventHandler<HTMLLIElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLLIElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLLIElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLLIElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLLIElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLLIElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLLIElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLLIElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLLIElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLLIElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLLIElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLLIElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLLIElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLLIElement>;
		onSelect?: import("react").ReactEventHandler<HTMLLIElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLLIElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLLIElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLLIElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLLIElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLLIElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLLIElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLLIElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLLIElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLLIElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLLIElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLLIElement>;
		onScroll?: import("react").UIEventHandler<HTMLLIElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLLIElement>;
		onWheel?: import("react").WheelEventHandler<HTMLLIElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLLIElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLLIElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLLIElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLLIElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLLIElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLLIElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLLIElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLLIElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLLIElement>;
		}>;
		export declare const ListItemName: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
		selected?: boolean;
		theme?: Theme;
		}, never>;
		export declare const ListItemBullet: import("styled-components").StyledComponent<"span", any, {
		}>>;
		export declare const ListItemBullet: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
		selected?: boolean;
		theme?: Theme;
		}, never>;
		}>>;

dist/components/timeline-horizontal/timeline-horizontal.styles.d.ts

		@@ -1,6 +0,7 @@
		export declare const TimelineHorizontalWrapper: import("styled-components").StyledComponent<"ul", any, {
		/// <reference types="react" />
		export declare const TimelineHorizontalWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, {
		flipLayout?: boolean;
		}, never>;
		export declare const TimelineItemWrapper: import("styled-components").StyledComponent<"li", any, {
		}>>;
		export declare const TimelineItemWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, {
		width: number;
		}, never>;
		}>>;

279

dist/components/timeline-vertical/timeline-vertical-shape.styles.d.ts

		@@ -1,6 +0,279 @@
		export declare const TimelinePointWrapper: import("styled-components").StyledComponent<"div", any, {
		/// <reference types="react" />
		/// <reference types="react" />
		export declare const TimelinePointWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$cardLess?: boolean;
		bg?: string;
		width?: number;
		}, never>;
		export declare const TimelinePointContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
		}>>;
		export declare const TimelinePointContainer: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLDivElement>;
		key?: import("react").Key;
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "true" \| "false");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "true" \| "false";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "true" \| "false";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "search" \| "text" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "true" \| "false";
		'aria-autocomplete'?: "none" \| "list" \| "inline" \| "both";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "true" \| "false";
		'aria-checked'?: boolean \| "true" \| "false" \| "mixed";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "true" \| "false" \| "page" \| "step" \| "location" \| "date" \| "time";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "true" \| "false";
		'aria-dropeffect'?: "none" \| "link" \| "copy" \| "execute" \| "move" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "true" \| "false";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "true" \| "false";
		'aria-haspopup'?: boolean \| "true" \| "false" \| "dialog" \| "grid" \| "listbox" \| "menu" \| "tree";
		'aria-hidden'?: boolean \| "true" \| "false";
		'aria-invalid'?: boolean \| "true" \| "false" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "true" \| "false";
		'aria-multiline'?: boolean \| "true" \| "false";
		'aria-multiselectable'?: boolean \| "true" \| "false";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "true" \| "false" \| "mixed";
		'aria-readonly'?: boolean \| "true" \| "false";
		'aria-relevant'?: "text" \| "additions" \| "additions removals" \| "additions text" \| "all" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "true" \| "false";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "true" \| "false";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onFocus?: import("react").FocusEventHandler<HTMLDivElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLDivElement>;
		onBlur?: import("react").FocusEventHandler<HTMLDivElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLDivElement>;
		onChange?: import("react").FormEventHandler<HTMLDivElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLDivElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onInput?: import("react").FormEventHandler<HTMLDivElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onReset?: import("react").FormEventHandler<HTMLDivElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onSubmit?: import("react").FormEventHandler<HTMLDivElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onInvalid?: import("react").FormEventHandler<HTMLDivElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onLoad?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onError?: import("react").ReactEventHandler<HTMLDivElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onAbort?: import("react").ReactEventHandler<HTMLDivElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLDivElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLDivElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEnded?: import("react").ReactEventHandler<HTMLDivElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPause?: import("react").ReactEventHandler<HTMLDivElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlay?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onProgress?: import("react").ReactEventHandler<HTMLDivElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onResize?: import("react").ReactEventHandler<HTMLDivElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onStalled?: import("react").ReactEventHandler<HTMLDivElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLDivElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLDivElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLDivElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLDivElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onDrag?: import("react").DragEventHandler<HTMLDivElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragExit?: import("react").DragEventHandler<HTMLDivElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLDivElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragOver?: import("react").DragEventHandler<HTMLDivElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragStart?: import("react").DragEventHandler<HTMLDivElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDrop?: import("react").DragEventHandler<HTMLDivElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onSelect?: import("react").ReactEventHandler<HTMLDivElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onScroll?: import("react").UIEventHandler<HTMLDivElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLDivElement>;
		onWheel?: import("react").WheelEventHandler<HTMLDivElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLDivElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLDivElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDivElement>;
		}>;

287

dist/components/timeline-vertical/timeline-vertical.styles.d.ts

		@@ -0,5 +1,278 @@
		/// <reference types="react" />
		/// <reference types="react" />
		import { Theme } from '@models/Theme';
		import { TimelineMode } from '@models/TimelineModel';
		export declare const TimelineVerticalWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
		export declare const VerticalItemWrapper: import("styled-components").StyledComponent<"div", any, {
		export declare const TimelineVerticalWrapper: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLDivElement>;
		key?: import("react").Key;
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "false" \| "true");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "false" \| "true";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "false" \| "true";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "text" \| "search" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "false" \| "true";
		'aria-autocomplete'?: "none" \| "both" \| "inline" \| "list";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "false" \| "true";
		'aria-checked'?: boolean \| "mixed" \| "false" \| "true";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "page" \| "false" \| "true" \| "step" \| "location" \| "date" \| "time";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "false" \| "true";
		'aria-dropeffect'?: "none" \| "copy" \| "move" \| "link" \| "execute" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "false" \| "true";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "false" \| "true";
		'aria-haspopup'?: boolean \| "listbox" \| "grid" \| "menu" \| "false" \| "true" \| "dialog" \| "tree";
		'aria-hidden'?: boolean \| "false" \| "true";
		'aria-invalid'?: boolean \| "false" \| "true" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "false" \| "true";
		'aria-multiline'?: boolean \| "false" \| "true";
		'aria-multiselectable'?: boolean \| "false" \| "true";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "mixed" \| "false" \| "true";
		'aria-readonly'?: boolean \| "false" \| "true";
		'aria-relevant'?: "all" \| "text" \| "additions" \| "additions removals" \| "additions text" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "false" \| "true";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "false" \| "true";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onFocus?: import("react").FocusEventHandler<HTMLDivElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLDivElement>;
		onBlur?: import("react").FocusEventHandler<HTMLDivElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLDivElement>;
		onChange?: import("react").FormEventHandler<HTMLDivElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLDivElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onInput?: import("react").FormEventHandler<HTMLDivElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onReset?: import("react").FormEventHandler<HTMLDivElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onSubmit?: import("react").FormEventHandler<HTMLDivElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onInvalid?: import("react").FormEventHandler<HTMLDivElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onLoad?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onError?: import("react").ReactEventHandler<HTMLDivElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onAbort?: import("react").ReactEventHandler<HTMLDivElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLDivElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLDivElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEnded?: import("react").ReactEventHandler<HTMLDivElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPause?: import("react").ReactEventHandler<HTMLDivElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlay?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onProgress?: import("react").ReactEventHandler<HTMLDivElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onResize?: import("react").ReactEventHandler<HTMLDivElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onStalled?: import("react").ReactEventHandler<HTMLDivElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLDivElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLDivElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLDivElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLDivElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onDrag?: import("react").DragEventHandler<HTMLDivElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragExit?: import("react").DragEventHandler<HTMLDivElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLDivElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragOver?: import("react").DragEventHandler<HTMLDivElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragStart?: import("react").DragEventHandler<HTMLDivElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDrop?: import("react").DragEventHandler<HTMLDivElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onSelect?: import("react").ReactEventHandler<HTMLDivElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onScroll?: import("react").UIEventHandler<HTMLDivElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLDivElement>;
		onWheel?: import("react").WheelEventHandler<HTMLDivElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLDivElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLDivElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDivElement>;
		}>;
		export declare const VerticalItemWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$alternateCards?: boolean;
		@@ -10,4 +283,4 @@ $cardHeight?: number;
		theme?: Theme;
		}, never>;
		export declare const TimelineCardContentWrapper: import("styled-components").StyledComponent<"div", any, {
		}>>;
		export declare const TimelineCardContentWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$alternateCards?: boolean;
		@@ -18,4 +291,4 @@ $cardLess?: boolean;
		height?: number;
		}, never>;
		export declare const TimelineTitleWrapper: import("styled-components").StyledComponent<"div", any, {
		}>>;
		export declare const TimelineTitleWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$alternateCards?: boolean;
		@@ -25,2 +298,2 @@ $flip?: boolean;
		mode?: TimelineMode;
		}, never>;
		}>>;

295

dist/components/timeline/timeline.style.d.ts

		@@ -0,8 +1,10 @@
		/// <reference types="react" />
		/// <reference types="react" />
		import { Theme } from '@models/Theme';
		import { TimelineMode } from '@models/TimelineModel';
		export declare const Wrapper: import("styled-components").StyledComponent<"div", any, {
		export declare const Wrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$hideControls?: boolean;
		cardPositionHorizontal?: 'TOP' \| 'BOTTOM';
		}, never>;
		export declare const TimelineMainWrapper: import("styled-components").StyledComponent<"div", any, {
		}>>;
		export declare const TimelineMainWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$scrollable?: boolean \| {
		@@ -13,14 +15,285 @@ scrollbar: boolean;
		theme?: Theme;
		}, never>;
		export declare const TimelineMain: import("styled-components").StyledComponent<"div", any, {}, never>;
		export declare const Outline: import("styled-components").StyledComponent<"div", any, {
		}>>;
		export declare const TimelineMain: import("styled-components").IStyledComponent<"web", {
		ref?: import("react").LegacyRef<HTMLDivElement>;
		key?: import("react").Key;
		defaultChecked?: boolean;
		defaultValue?: string \| number \| readonly string[];
		suppressContentEditableWarning?: boolean;
		suppressHydrationWarning?: boolean;
		accessKey?: string;
		autoFocus?: boolean;
		className?: string;
		contentEditable?: "inherit" \| (boolean \| "false" \| "true");
		contextMenu?: string;
		dir?: string;
		draggable?: boolean \| "false" \| "true";
		hidden?: boolean;
		id?: string;
		lang?: string;
		nonce?: string;
		placeholder?: string;
		slot?: string;
		spellCheck?: boolean \| "false" \| "true";
		style?: import("react").CSSProperties;
		tabIndex?: number;
		title?: string;
		translate?: "yes" \| "no";
		radioGroup?: string;
		role?: import("react").AriaRole;
		about?: string;
		content?: string;
		datatype?: string;
		inlist?: any;
		prefix?: string;
		property?: string;
		rel?: string;
		resource?: string;
		rev?: string;
		typeof?: string;
		vocab?: string;
		autoCapitalize?: string;
		autoCorrect?: string;
		autoSave?: string;
		color?: string;
		itemProp?: string;
		itemScope?: boolean;
		itemType?: string;
		itemID?: string;
		itemRef?: string;
		results?: number;
		security?: string;
		unselectable?: "on" \| "off";
		inputMode?: "none" \| "text" \| "search" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal";
		is?: string;
		'aria-activedescendant'?: string;
		'aria-atomic'?: boolean \| "false" \| "true";
		'aria-autocomplete'?: "none" \| "both" \| "inline" \| "list";
		'aria-braillelabel'?: string;
		'aria-brailleroledescription'?: string;
		'aria-busy'?: boolean \| "false" \| "true";
		'aria-checked'?: boolean \| "mixed" \| "false" \| "true";
		'aria-colcount'?: number;
		'aria-colindex'?: number;
		'aria-colindextext'?: string;
		'aria-colspan'?: number;
		'aria-controls'?: string;
		'aria-current'?: boolean \| "page" \| "false" \| "true" \| "step" \| "location" \| "date" \| "time";
		'aria-describedby'?: string;
		'aria-description'?: string;
		'aria-details'?: string;
		'aria-disabled'?: boolean \| "false" \| "true";
		'aria-dropeffect'?: "none" \| "copy" \| "move" \| "link" \| "execute" \| "popup";
		'aria-errormessage'?: string;
		'aria-expanded'?: boolean \| "false" \| "true";
		'aria-flowto'?: string;
		'aria-grabbed'?: boolean \| "false" \| "true";
		'aria-haspopup'?: boolean \| "listbox" \| "grid" \| "menu" \| "false" \| "true" \| "dialog" \| "tree";
		'aria-hidden'?: boolean \| "false" \| "true";
		'aria-invalid'?: boolean \| "false" \| "true" \| "grammar" \| "spelling";
		'aria-keyshortcuts'?: string;
		'aria-label'?: string;
		'aria-labelledby'?: string;
		'aria-level'?: number;
		'aria-live'?: "off" \| "assertive" \| "polite";
		'aria-modal'?: boolean \| "false" \| "true";
		'aria-multiline'?: boolean \| "false" \| "true";
		'aria-multiselectable'?: boolean \| "false" \| "true";
		'aria-orientation'?: "horizontal" \| "vertical";
		'aria-owns'?: string;
		'aria-placeholder'?: string;
		'aria-posinset'?: number;
		'aria-pressed'?: boolean \| "mixed" \| "false" \| "true";
		'aria-readonly'?: boolean \| "false" \| "true";
		'aria-relevant'?: "all" \| "text" \| "additions" \| "additions removals" \| "additions text" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals";
		'aria-required'?: boolean \| "false" \| "true";
		'aria-roledescription'?: string;
		'aria-rowcount'?: number;
		'aria-rowindex'?: number;
		'aria-rowindextext'?: string;
		'aria-rowspan'?: number;
		'aria-selected'?: boolean \| "false" \| "true";
		'aria-setsize'?: number;
		'aria-sort'?: "none" \| "ascending" \| "descending" \| "other";
		'aria-valuemax'?: number;
		'aria-valuemin'?: number;
		'aria-valuenow'?: number;
		'aria-valuetext'?: string;
		children?: import("react").ReactNode;
		dangerouslySetInnerHTML?: {
		__html: string \| TrustedHTML;
		};
		onCopy?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCopyCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCut?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCutCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onPaste?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onPasteCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
		onCompositionEnd?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionStart?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDivElement>;
		onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
		onFocus?: import("react").FocusEventHandler<HTMLDivElement>;
		onFocusCapture?: import("react").FocusEventHandler<HTMLDivElement>;
		onBlur?: import("react").FocusEventHandler<HTMLDivElement>;
		onBlurCapture?: import("react").FocusEventHandler<HTMLDivElement>;
		onChange?: import("react").FormEventHandler<HTMLDivElement>;
		onChangeCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onBeforeInput?: import("react").FormEventHandler<HTMLDivElement>;
		onBeforeInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onInput?: import("react").FormEventHandler<HTMLDivElement>;
		onInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onReset?: import("react").FormEventHandler<HTMLDivElement>;
		onResetCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onSubmit?: import("react").FormEventHandler<HTMLDivElement>;
		onSubmitCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onInvalid?: import("react").FormEventHandler<HTMLDivElement>;
		onInvalidCapture?: import("react").FormEventHandler<HTMLDivElement>;
		onLoad?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onError?: import("react").ReactEventHandler<HTMLDivElement>;
		onErrorCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onKeyDown?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyPress?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyUp?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
		onAbort?: import("react").ReactEventHandler<HTMLDivElement>;
		onAbortCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlay?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayThrough?: import("react").ReactEventHandler<HTMLDivElement>;
		onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onDurationChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEmptied?: import("react").ReactEventHandler<HTMLDivElement>;
		onEmptiedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEncrypted?: import("react").ReactEventHandler<HTMLDivElement>;
		onEncryptedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onEnded?: import("react").ReactEventHandler<HTMLDivElement>;
		onEndedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedData?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedMetadata?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadStart?: import("react").ReactEventHandler<HTMLDivElement>;
		onLoadStartCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPause?: import("react").ReactEventHandler<HTMLDivElement>;
		onPauseCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlay?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlaying?: import("react").ReactEventHandler<HTMLDivElement>;
		onPlayingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onProgress?: import("react").ReactEventHandler<HTMLDivElement>;
		onProgressCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onRateChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onRateChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onResize?: import("react").ReactEventHandler<HTMLDivElement>;
		onResizeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeeked?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeekedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeeking?: import("react").ReactEventHandler<HTMLDivElement>;
		onSeekingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onStalled?: import("react").ReactEventHandler<HTMLDivElement>;
		onStalledCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onSuspend?: import("react").ReactEventHandler<HTMLDivElement>;
		onSuspendCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onTimeUpdate?: import("react").ReactEventHandler<HTMLDivElement>;
		onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onVolumeChange?: import("react").ReactEventHandler<HTMLDivElement>;
		onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onWaiting?: import("react").ReactEventHandler<HTMLDivElement>;
		onWaitingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onAuxClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onAuxClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onContextMenu?: import("react").MouseEventHandler<HTMLDivElement>;
		onContextMenuCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onDoubleClick?: import("react").MouseEventHandler<HTMLDivElement>;
		onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onDrag?: import("react").DragEventHandler<HTMLDivElement>;
		onDragCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnd?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEndCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnter?: import("react").DragEventHandler<HTMLDivElement>;
		onDragEnterCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragExit?: import("react").DragEventHandler<HTMLDivElement>;
		onDragExitCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragLeave?: import("react").DragEventHandler<HTMLDivElement>;
		onDragLeaveCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragOver?: import("react").DragEventHandler<HTMLDivElement>;
		onDragOverCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDragStart?: import("react").DragEventHandler<HTMLDivElement>;
		onDragStartCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onDrop?: import("react").DragEventHandler<HTMLDivElement>;
		onDropCapture?: import("react").DragEventHandler<HTMLDivElement>;
		onMouseDown?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseDownCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseMove?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOut?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOutCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOver?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseOverCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseUp?: import("react").MouseEventHandler<HTMLDivElement>;
		onMouseUpCapture?: import("react").MouseEventHandler<HTMLDivElement>;
		onSelect?: import("react").ReactEventHandler<HTMLDivElement>;
		onSelectCapture?: import("react").ReactEventHandler<HTMLDivElement>;
		onTouchCancel?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchEnd?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchEndCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchMove?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchStart?: import("react").TouchEventHandler<HTMLDivElement>;
		onTouchStartCapture?: import("react").TouchEventHandler<HTMLDivElement>;
		onPointerDown?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerDownCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerMove?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerUp?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerUpCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerCancel?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerEnter?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerEnterCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerLeave?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOver?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOverCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOut?: import("react").PointerEventHandler<HTMLDivElement>;
		onPointerOutCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onGotPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onLostPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
		onScroll?: import("react").UIEventHandler<HTMLDivElement>;
		onScrollCapture?: import("react").UIEventHandler<HTMLDivElement>;
		onWheel?: import("react").WheelEventHandler<HTMLDivElement>;
		onWheelCapture?: import("react").WheelEventHandler<HTMLDivElement>;
		onAnimationStart?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationEnd?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationIteration?: import("react").AnimationEventHandler<HTMLDivElement>;
		onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
		onTransitionEnd?: import("react").TransitionEventHandler<HTMLDivElement>;
		onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDivElement>;
		}>;
		export declare const Outline: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		color?: string;
		height?: number;
		}, never>;
		export declare const TimelineControlContainer: import("styled-components").StyledComponent<"div", any, {
		}>>;
		export declare const TimelineControlContainer: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		active?: boolean;
		mode?: TimelineMode;
		}, never>;
		export declare const TimelineContentRender: import("styled-components").StyledComponent<"div", any, {
		}>>;
		export declare const TimelineContentRender: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
		$showAllCards?: boolean;
		}, never>;
		}>>;

dist/models/TimelineMediaModel.d.ts

		@@ -1,3 +0,4 @@
		import { ReactNode } from 'react';
		import { ForwardRefExoticComponent, ReactNode } from 'react';
		import { Theme } from './Theme';
		import { TextOrContentModel } from '../components/timeline-elements/timeline-card-content/text-or-content';
		export type MediaType = 'VIDEO' \| 'IMAGE';
		@@ -22,3 +23,3 @@ export interface MediaSource {
		content?: string \| ReactNode;
		detailsText?: ReactNode;
		detailsText?: ForwardRefExoticComponent<TextOrContentModel>;
		hideMedia: boolean;
		@@ -25,0 +26,0 @@ id?: string;

dist/models/TimelineModel.d.ts

		@@ -0,1 +1,2 @@
		/// <reference types="react" />
		import { Theme } from './Theme';
		@@ -2,0 +3,0 @@ import { TimelineItemModel } from './TimelineItemModel';

dist/models/TimelineVerticalModel.d.ts

		@@ -0,1 +1,2 @@
		/// <reference types="react" />
		import { Theme } from './Theme';
		@@ -2,0 +3,0 @@ import { Scroll } from './TimelineHorizontalModel';

103

package.json

		{
		"name": "react-chrono",
		"version": "2.2.2",
		"version": "2.2.3",
		"license": "MIT",
		@@ -19,2 +19,3 @@ "description": "A Modern Timeline component for React",
		"cypress": "cypress open",
		"cypress:headless": "cypress run --headless",
		"cypress:record": "cypress run --record --key 0a753295-339a-4351-bf1d-6b91d4bcb937",
		@@ -37,3 +38,5 @@ "cypress:runner": "start-server-and-test start http://localhost:4444 cypress:record",
		"vite:build": "vite build --config vite.config.ts",
		"coveralls": "pnpx coveralls < coverage/lcov.info"
		"coveralls": "pnpx coveralls < coverage/lcov.info",
		"size-limit": "pnpm rollup && pnpm size-limit",
		"build": "pnpm rollup"
		},
		@@ -44,3 +47,3 @@ "dependencies": {
		"focus-visible": "^5.2.0",
		"styled-components": "=5.3.10"
		"styled-components": "^6.0.7"
		},
		@@ -56,45 +59,44 @@ "peerDependencies": {
		"devDependencies": {
		"@babel/core": "^7.22.5",
		"@babel/core": "^7.22.9",
		"@babel/plugin-proposal-optional-chaining": "^7.21.0",
		"@babel/plugin-transform-runtime": "^7.22.5",
		"@babel/plugin-transform-typescript": "^7.22.5",
		"@babel/preset-env": "^7.22.5",
		"@babel/plugin-transform-runtime": "^7.22.9",
		"@babel/plugin-transform-typescript": "^7.22.9",
		"@babel/preset-env": "^7.22.9",
		"@babel/preset-react": "^7.22.5",
		"@babel/preset-typescript": "^7.22.5",
		"@emotion/babel-plugin": "^11.11.0",
		"@jest/types": "^29.5.0",
		"@jest/types": "^29.6.1",
		"@rollup/plugin-babel": "^6.0.3",
		"@rollup/plugin-buble": "^1.0.2",
		"@rollup/plugin-commonjs": "^25.0.2",
		"@rollup/plugin-commonjs": "^25.0.3",
		"@rollup/plugin-node-resolve": "^15.1.0",
		"@rollup/plugin-strip": "^3.0.2",
		"@stylelint/postcss-css-in-js": "^0.38.0",
		"@rollup/plugin-terser": "^0.4.3",
		"@size-limit/preset-big-lib": "^8.2.6",
		"@testing-library/dom": "^9.3.1",
		"@testing-library/jest-dom": "^5.16.5",
		"@testing-library/jest-dom": "^5.17.0",
		"@testing-library/react": "^14.0.0",
		"@testing-library/user-event": "^14.4.3",
		"@types/classnames": "^2.3.1",
		"@types/jest": "^29.5.2",
		"@types/node": "^20.3.3",
		"@types/react": "^18.2.14",
		"@types/react-dom": "^18.2.6",
		"@types/jest": "^29.5.3",
		"@types/node": "^20.4.7",
		"@types/react": "^18.2.18",
		"@types/react-dom": "^18.2.7",
		"@types/react-router-dom": "^5.3.3",
		"@types/styled-components": "^5.1.26",
		"@types/testing-library__jest-dom": "^5.14.6",
		"@typescript-eslint/eslint-plugin": "^5.60.1",
		"@typescript-eslint/parser": "^5.60.1",
		"@vitejs/plugin-react": "^4.0.1",
		"@vitest/coverage-c8": "^0.32.2",
		"@vitest/coverage-v8": "^0.32.2",
		"@types/testing-library__jest-dom": "^5.14.9",
		"@typescript-eslint/eslint-plugin": "^6.2.1",
		"@typescript-eslint/parser": "^6.2.1",
		"@vitejs/plugin-react": "^4.0.4",
		"@vitest/coverage-v8": "^0.34.1",
		"autoprefixer": "^10.4.14",
		"babel-loader": "^9.1.2",
		"babel-loader": "^9.1.3",
		"babel-plugin-styled-components": "^2.1.4",
		"c8": "^8.0.0",
		"c8": "^8.0.1",
		"cssnano": "^6.0.1",
		"cypress": "12.16.0",
		"eslint": "^8.44.0",
		"eslint-config-prettier": "^8.8.0",
		"eslint-plugin-import": "^2.27.5",
		"cypress": "12.17.3",
		"eslint": "^8.46.0",
		"eslint-config-prettier": "^8.10.0",
		"eslint-plugin-import": "^2.28.0",
		"eslint-plugin-jsx-a11y": "^6.7.1",
		"eslint-plugin-react": "^7.32.2",
		"eslint-plugin-react": "^7.33.1",
		"eslint-plugin-sort-keys-fix": "^1.1.2",
		@@ -105,6 +107,6 @@ "eslint-plugin-typescript-sort-keys": "^2.3.0",
		"lint-staged": "^13.2.3",
		"postcss": "^8.4.24",
		"postcss-preset-env": "^8.5.1",
		"postcss": "^8.4.27",
		"postcss-preset-env": "^9.1.0",
		"postcss-syntax": "^0.36.2",
		"prettier": "^2.8.8",
		"prettier": "^3.0.1",
		"pretty-quick": "^3.1.3",
		@@ -114,5 +116,5 @@ "react": "^18.2.0",
		"react-is": "^18.2.0",
		"react-router-dom": "^6.14.1",
		"react-router-dom": "^6.14.2",
		"rimraf": "^5.0.1",
		"rollup": "^3.26.0",
		"rollup": "^3.27.2",
		"rollup-plugin-analyzer": "^4.0.0",
		@@ -125,20 +127,21 @@ "rollup-plugin-copy": "^3.4.0",
		"rollup-plugin-typescript2": "^0.35.0",
		"sass": "^1.63.6",
		"snyk": "^1.1187.0",
		"sass": "^1.64.2",
		"semver": "^7.5.4",
		"size-limit": "^8.2.6",
		"snyk": "^1.1200.0",
		"start-server-and-test": "^2.0.0",
		"stylelint": "^15.9.0",
		"stylelint-config-recommended": "^12.0.0",
		"stylelint": "^15.10.2",
		"stylelint-config-recommended": "^13.0.0",
		"stylelint-config-styled-components": "^0.1.1",
		"stylelint-order": "^6.0.3",
		"stylelint-processor-styled-components": "^1.10.0",
		"tailwindcss": "^3.3.2",
		"typescript": "^5.1.6",
		"vite": "^4.3.9",
		"vite": "^4.4.8",
		"vite-tsconfig-paths": "^4.2.0",
		"vitest": "^0.32.2",
		"webpack": "^5.88.1"
		"vitest": "^0.34.1"
		},
		"resolutions": {
		"ansi-regex": "5.0.1",
		"json-schema": "0.4.0"
		"json-schema": "0.4.0",
		"semver": "7.5.4"
		},
		@@ -148,2 +151,16 @@ "files": [
		],
		"size-limit": [
		{
		"path": "dist/react-chrono.js",
		"limit": "50 KB"
		},
		{
		"path": "dist/react-chrono.esm.js",
		"limit": "50 KB"
		},
		{
		"path": "dist/react-chrono.umd.js",
		"limit": "50 KB"
		}
		],
		"lint-staged": {
		@@ -150,0 +167,0 @@ "src/components/*/.{ts,tsx}": [

dist/components/timeline-elements/timeline-card/timeline-horizontal-card.styles.d.ts

Sorry, the diff of this file is too big to display

dist/react-chrono.esm.js

Sorry, the diff of this file is too big to display

dist/react-chrono.js

Sorry, the diff of this file is too big to display

dist/react-chrono.umd.js

Sorry, the diff of this file is too big to display

react-chrono - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes