Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

react-chrono

Package Overview
Dependencies
Maintainers
1
Versions
122
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

react-chrono - npm Package Compare versions

Comparing version 2.2.4 to 2.2.5

dist/components/effects/__tests__/useMatchMedia.test.d.ts
dist/components/timeline-elements/timeline-outline/__tests__/timeline-outline.test.d.ts
dist/utils/utils.test.d.ts

2

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

@@ -1,1 +0,1 @@

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

4

dist/components/effects/useMatchMedia.d.ts

@@ -1,5 +0,1 @@

/**
The useMatchMedia hook takes a media query string, a callback function, and an enabled boolean.
It returns a boolean indicating if the media query matches the current viewport and executes the callback if it does.
**/
export declare const useMatchMedia: (query: string, cb?: () => void, enabled?: boolean) => boolean;

9

dist/components/effects/useNewScrollPosition.d.ts
import { Scroll } from '@models/TimelineHorizontalModel';
import { TimelineMode } from '@models/TimelineModel';
declare let useNewScrollPosition: (mode: TimelineMode, itemWidth?: number) => [number, (e: HTMLElement, s: Partial<Scroll>) => void];
/**
* Hook to calculate the new scroll position based on the given mode and item width.
*
* @param {TimelineMode} mode - The mode of the timeline (HORIZONTAL, VERTICAL, or VERTICAL_ALTERNATING).
* @param {number} [itemWidth] - Optional item width for horizontal mode.
* @returns {[number, (e: HTMLElement, s: Partial<Scroll>) => void]} - The new offset and a function to compute the new offset.
*/
declare const useNewScrollPosition: (mode: TimelineMode, itemWidth?: number) => [number, (e: HTMLElement, s: Partial<Scroll>) => void];
export default useNewScrollPosition;

1

dist/components/GlobalContext.d.ts

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { TimelineProps as PropsModel } from '@models/TimelineModel';

@@ -2,0 +3,0 @@ import { FunctionComponent } from 'react';

1

dist/components/icons/chev-left.d.ts

@@ -0,3 +1,4 @@

/// <reference types="@types/react" />
import React from 'react';
declare const ChevronLeft: React.FunctionComponent;
export default ChevronLeft;

1

dist/components/icons/chev-right.d.ts

@@ -0,3 +1,4 @@

/// <reference types="@types/react" />
import React from 'react';
declare const ChevronRightIcon: React.FunctionComponent;
export default ChevronRightIcon;

1

dist/components/icons/chevs-left.d.ts

@@ -0,3 +1,4 @@

/// <reference types="@types/react" />
import React from 'react';
declare const ChevronLeft: React.FunctionComponent;
export default ChevronLeft;

1

dist/components/icons/chevs-right.d.ts

@@ -0,3 +1,4 @@

/// <reference types="@types/react" />
import React from 'react';
declare const ChevronRightIcon: React.FunctionComponent;
export default ChevronRightIcon;

1

dist/components/icons/replay-icon.d.ts

@@ -0,3 +1,4 @@

/// <reference types="@types/react" />
import React from 'react';
declare const ReplayIcon: React.FunctionComponent;
export default ReplayIcon;

1

dist/components/index.d.ts

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { TimelineProps } from '@models/TimelineModel';

@@ -2,0 +3,0 @@ import 'focus-visible';

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import React from 'react';

@@ -2,0 +3,0 @@ import { Content, DetailsTextMemoModel, ExpandButtonModel, ShowHideTextButtonModel, Title } from './memoized-model';

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { Theme } from '@models/Theme';

@@ -2,0 +3,0 @@ import React, { ForwardRefExoticComponent, ReactNode } from 'react';

8

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

@@ -1,4 +0,4 @@

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;
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;

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { FunctionComponent } from 'react';

@@ -2,0 +3,0 @@ import { ContentFooterProps } from './header-footer.model';

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { FunctionComponent } from 'react';

@@ -2,0 +3,0 @@ import { ContentHeaderProps } from './header-footer.model';

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { ReactNode } from 'react';

@@ -2,0 +3,0 @@ import { TimelineContentModel } from '@models/TimelineContentModel';

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { Theme } from '@models/Theme';

@@ -2,0 +3,0 @@ import { TimelineContentModel } from '@models/TimelineContentModel';

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { TimelineContentModel } from '@models/TimelineContentModel';

@@ -2,0 +3,0 @@ import { ForwardRefExoticComponent } from 'react';

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { TimelineContentModel } from '@models/TimelineContentModel';

@@ -2,0 +3,0 @@ import React from 'react';

596

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

@@ -1,7 +0,5 @@

/// <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").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, {
export declare const TimelineItemContentWrapper: import("styled-components").StyledComponent<"section", any, {
$active?: boolean;

@@ -18,276 +16,5 @@ $borderLessCards?: TimelineProps['borderLessCards'];

$textOverlay?: boolean;
} & 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>, {
} & ContentT, never>;
export declare const TimelineCardHeader: import("styled-components").StyledComponent<"header", any, {}, never>;
export declare const CardSubTitle: import("styled-components").StyledComponent<"h2", any, {
$fontSize?: string;

@@ -297,4 +24,4 @@ $padding?: boolean;

theme?: Theme;
}>>;
export declare const CardTitle: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {
}, never>;
export declare const CardTitle: import("styled-components").StyledComponent<"h1", any, {
$fontSize: string;

@@ -304,291 +31,12 @@ $padding?: boolean;

theme: Theme;
}>>;
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>, {
}, never>;
export declare const CardTitleAnchor: import("styled-components").StyledComponent<"a", any, {}, never>;
export declare const TimelineContentDetails: import("styled-components").StyledComponent<"p", any, {
theme?: Theme;
}>>;
export declare const TimelineSubContent: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
}, never>;
export declare const TimelineSubContent: import("styled-components").StyledComponent<"span", any, {
fontSize?: string;
theme?: Theme;
}>>;
export declare const TimelineContentDetailsWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
}, never>;
export declare const TimelineContentDetailsWrapper: import("styled-components").StyledComponent<"div", any, {
$borderLess?: boolean;

@@ -605,8 +53,8 @@ $cardHeight?: number | null;

theme?: Theme;
}>>;
export declare const ShowMore: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
}, never>;
export declare const ShowMore: import("styled-components").StyledComponent<"button", any, {
show?: 'true' | 'false';
theme?: Theme;
}>>;
export declare const SlideShowProgressBar: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
}, never>;
export declare const SlideShowProgressBar: import("styled-components").StyledComponent<"span", any, {
$color?: string;

@@ -617,11 +65,11 @@ $duration?: number;

$startWidth?: number;
}>>;
export declare const ChevronIconWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
}, never>;
export declare const ChevronIconWrapper: import("styled-components").StyledComponent<"span", any, {
collapsed?: 'true' | 'false';
}>>;
export declare const TriangleIconWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
}, never>;
export declare const TriangleIconWrapper: import("styled-components").StyledComponent<"span", any, {
dir?: string;
offset?: number;
theme?: Theme;
}>>;
}, never>;
export {};

283

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

@@ -1,282 +0,9 @@

/// <reference types="react" />
/// <reference types="react" />
import { Theme } from '@models/Theme';
export declare const ExpandButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
export declare const ExpandButton: import("styled-components").StyledComponent<"button", any, {
theme: Theme;
}>>;
export declare const ShowHideTextButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
}, never>;
export declare const ShowHideTextButton: import("styled-components").StyledComponent<"button", any, {
showText?: boolean;
theme: Theme;
}>>;
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>;
}>;
}, never>;
export declare const ButtonWrapper: import("styled-components").StyledComponent<"ul", any, {}, never>;

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { CardMediaModel } from '@models/TimelineMediaModel';

@@ -2,0 +3,0 @@ import React from 'react';

863

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

@@ -1,7 +0,5 @@

/// <reference types="react" />
/// <reference types="react" />
import { Theme } from '@models/Theme';
import { TimelineMode } from '@models/TimelineModel';
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>, {
export declare const linearGradient: import("styled-components").FlattenSimpleInterpolation;
export declare const MediaWrapper: import("styled-components").StyledComponent<"div", any, {
$active?: boolean;

@@ -15,4 +13,4 @@ $cardHeight?: number;

theme?: Theme;
}>>;
export declare const CardImage: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, {
}, never>;
export declare const CardImage: import("styled-components").StyledComponent<"img", any, {
$enableBorderRadius?: boolean;

@@ -23,7 +21,7 @@ $visible?: boolean;

mode?: TimelineMode;
}>>;
export declare const CardVideo: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, {
}, never>;
export declare const CardVideo: import("styled-components").StyledComponent<"video", any, {
height?: number;
}>>;
export declare const MediaDetailsWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
}, never>;
export declare const MediaDetailsWrapper: import("styled-components").StyledComponent<"div", any, {
$absolutePosition?: boolean;

@@ -38,564 +36,6 @@ $borderLessCard?: boolean;

theme?: Theme;
}>>;
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>, {
}, 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, {
$expandFull?: boolean;

@@ -605,277 +45,6 @@ $show?: boolean;

theme?: Theme;
}>>;
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>, {
}, never>;
export declare const CardMediaHeader: import("styled-components").StyledComponent<"div", any, {}, never>;
export declare const ImageWrapper: import("styled-components").StyledComponent<"div", any, {
height?: number;
}>>;
}, never>;

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { TimelineCardModel } from '@models/TimelineItemModel';

@@ -2,0 +3,0 @@ import React from 'react';

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { TimelineControlModel } from '@models/TimelineControlModel';

@@ -2,0 +3,0 @@ import React from 'react';

859

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

@@ -1,856 +0,23 @@

/// <reference types="react" />
/// <reference types="react" />
import { Theme } from '@models/Theme';
import { TimelineMode } from '@models/TimelineModel';
export declare const TimelineNavWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, {
export declare const TimelineNavWrapper: import("styled-components").StyledComponent<"ul", any, {
theme?: Theme;
}>>;
export declare const TimelineNavItem: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, {
}, never>;
export declare const TimelineNavItem: import("styled-components").StyledComponent<"li", any, {
$disable?: boolean;
}>>;
export declare const TimelineNavButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
}, never>;
export declare const TimelineNavButton: import("styled-components").StyledComponent<"button", any, {
mode?: TimelineMode;
rotate?: 'TRUE' | 'FALSE';
theme?: Theme;
}>>;
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>, {
}, never>;
export declare const TimelineControlContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
export declare const ControlButton: import("styled-components").StyledComponent<"button", any, {
theme?: Theme;
}>>;
export declare const MediaToggle: import("styled-components").IStyledComponent<"web", {
}, never>;
export declare const MediaToggle: import("styled-components").StyledComponent<"button", any, {
theme?: Theme;
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", {
}, never>;
export declare const ReplayWrapper: import("styled-components").StyledComponent<"button", any, {
theme?: Theme;
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>;
}>;
}, never>;

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { TitleModel } from '@models/TimelineCardTitleModel';

@@ -2,0 +3,0 @@ import React from 'react';

5

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

@@ -1,4 +0,3 @@

/// <reference types="react" />
import { Theme } from '@models/Theme';
export declare const TitleWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
export declare const TitleWrapper: import("styled-components").StyledComponent<"div", any, {
$fontSize?: string;

@@ -8,2 +7,2 @@ $hide?: boolean;

theme?: Theme;
}>>;
}, never>;

1

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { Theme } from '@models/Theme';

@@ -2,0 +3,0 @@ import { FunctionComponent } from 'react';

3

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

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { Theme } from '@models/Theme';

@@ -8,3 +9,3 @@ import { TimelineMode } from '@models/TimelineModel';

}
interface TimelineOutlineModel {
export interface TimelineOutlineModel {
items?: TimelineOutlineItem[];

@@ -11,0 +12,0 @@ mode?: TimelineMode;

569

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

@@ -1,569 +0,24 @@

/// <reference types="react" />
/// <reference types="react" />
import { Theme } from '@models/Theme';
import { OutlinePosition } from './timeline-outline';
export declare const OutlineWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
export declare const OutlineWrapper: import("styled-components").StyledComponent<"div", any, {
open?: boolean;
position?: OutlinePosition;
}>>;
export declare const OutlinePane: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, {
}, never>;
export declare const OutlinePane: import("styled-components").StyledComponent<"aside", any, {
open?: boolean;
}>>;
export declare const OutlineButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
}, never>;
export declare const OutlineButton: import("styled-components").StyledComponent<"button", any, {
open?: boolean;
position?: OutlinePosition;
theme?: Theme;
}>>;
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>, {
}, 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, {
selected?: boolean;
theme?: Theme;
}>>;
export declare const ListItemBullet: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
}, never>;
export declare const ListItemBullet: import("styled-components").StyledComponent<"span", any, {
selected?: boolean;
theme?: Theme;
}>>;
}, never>;

16

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

@@ -0,4 +1,20 @@

/// <reference types="@types/react" />
import { TimelineHorizontalModel } from '@models/TimelineHorizontalModel';
import React from 'react';
/**
* TimelineHorizontal
* @property {TimelineHorizontalModel} items - The items to be displayed in the timeline.
* @property {(item: TimelineItem) => void} handleItemClick - Function to handle item click.
* @property {boolean} autoScroll - Whether to auto-scroll the timeline.
* @property {string} wrapperId - The ID of the wrapper element.
* @property {boolean} slideShowRunning - Whether the slideshow is running.
* @property {() => void} onElapsed - Function to handle elapsed time.
* @property {React.ReactNode} contentDetailsChildren - The children nodes for content details.
* @property {boolean} hasFocus - Whether the timeline has focus.
* @property {React.ReactNode} iconChildren - The children nodes for icons.
* @property {number} nestedCardHeight - The height of the nested card.
* @property {boolean} isNested - Whether the card is nested.
* @returns {JSX.Element} The TimelineHorizontal component.
*/
declare const TimelineHorizontal: React.FunctionComponent<TimelineHorizontalModel>;
export default TimelineHorizontal;

9

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

@@ -1,7 +0,6 @@

/// <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>, {
export declare const TimelineHorizontalWrapper: import("styled-components").StyledComponent<"ul", any, {
flipLayout?: boolean;
}>>;
export declare const TimelineItemWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, {
}, never>;
export declare const TimelineItemWrapper: import("styled-components").StyledComponent<"li", any, {
width: number;
}>>;
}, never>;

16

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

@@ -0,4 +1,20 @@

/// <reference types="@types/react" />
import { TimelinePointModel } from '@models/TimelineVerticalModel';
import React from 'react';
/**
* TimelinePoint
* @property {string} className - The class name for the component.
* @property {string} id - The id of the timeline point.
* @property {() => void} onClick - Function to handle click event.
* @property {boolean} active - Whether the timeline point is active.
* @property {() => void} onActive - Function to handle active event.
* @property {boolean} slideShowRunning - Whether the slideshow is running.
* @property {React.ReactNode} iconChild - The icon child nodes.
* @property {number} timelinePointDimension - The dimension of the timeline point.
* @property {number} lineWidth - The width of the line.
* @property {boolean} disableClickOnCircle - Whether the click on circle is disabled.
* @property {boolean} cardLess - Whether the card is less.
* @returns {JSX.Element} The TimelinePoint component.
*/
declare const TimelinePoint: React.FunctionComponent<TimelinePointModel>;
export { TimelinePoint };

27

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

@@ -0,4 +1,31 @@

/// <reference types="@types/react" />
import { VerticalItemModel } from '@models/TimelineVerticalModel';
import React from 'react';
/**
* VerticalItem
* @property {boolean} active - Whether the vertical item is active.
* @property {boolean} alternateCards - Whether to alternate cards.
* @property {string} cardDetailedText - The detailed text of the card.
* @property {string} cardSubtitle - The subtitle of the card.
* @property {string} cardTitle - The title of the card.
* @property {string} url - The URL of the card.
* @property {string} className - The class name for the component.
* @property {React.ReactNode} contentDetailsChildren - The content details children nodes.
* @property {React.ReactNode} iconChild - The icon child nodes.
* @property {boolean} hasFocus - Whether the vertical item has focus.
* @property {string} id - The id of the vertical item.
* @property {React.ReactNode} media - The media nodes.
* @property {() => void} onActive - Function to handle active event.
* @property {() => void} onClick - Function to handle click event.
* @property {() => void} onElapsed - Function to handle elapsed event.
* @property {boolean} slideShowRunning - Whether the slideshow is running.
* @property {string} title - The title of the vertical item.
* @property {boolean} visible - Whether the vertical item is visible.
* @property {React.ReactNode} timelineContent - The timeline content nodes.
* @property {Array} items - The items of the vertical item.
* @property {boolean} isNested - Whether the vertical item is nested.
* @property {number} nestedCardHeight - The height of the nested card.
* @returns {JSX.Element} The VerticalItem component.
*/
declare const VerticalItem: React.FunctionComponent<VerticalItemModel>;
export default VerticalItem;

279

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

@@ -1,279 +0,6 @@

/// <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>, {
export declare const TimelinePointWrapper: import("styled-components").StyledComponent<"div", any, {
$cardLess?: boolean;
bg?: string;
width?: number;
}>>;
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>;
}>;
}, never>;
export declare const TimelinePointContainer: import("styled-components").StyledComponent<"div", any, {}, never>;

20

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

@@ -0,4 +1,24 @@

/// <reference types="@types/react" />
import { TimelineVerticalModel } from '@models/TimelineVerticalModel';
import React from 'react';
/**
* TimelineVertical
* @property {boolean} alternateCards - Whether to alternate cards.
* @property {() => void} autoScroll - Function to handle auto scroll.
* @property {React.ReactNode} contentDetailsChildren - The content details children nodes.
* @property {boolean} enableOutline - Whether to enable outline.
* @property {boolean} hasFocus - Whether the timeline has focus.
* @property {React.ReactNode} iconChildren - The icon children nodes.
* @property {Array} items - The items of the timeline.
* @property {string} mode - The mode of the timeline.
* @property {() => void} onClick - Function to handle click event.
* @property {() => void} onElapsed - Function to handle elapsed event.
* @property {() => void} onOutlineSelection - Function to handle outline selection.
* @property {boolean} slideShowRunning - Whether the slideshow is running.
* @property {Object} theme - The theme of the timeline.
* @property {boolean} cardLess - Whether the card is less.
* @property {number} nestedCardHeight - The height of the nested card.
* @returns {JSX.Element} The TimelineVertical component.
*/
declare const TimelineVertical: React.FunctionComponent<TimelineVerticalModel>;
export default TimelineVertical;

287

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

@@ -1,278 +0,5 @@

/// <reference types="react" />
/// <reference types="react" />
import { Theme } from '@models/Theme';
import { TimelineMode } from '@models/TimelineModel';
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>, {
export declare const TimelineVerticalWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
export declare const VerticalItemWrapper: import("styled-components").StyledComponent<"div", any, {
$alternateCards?: boolean;

@@ -283,4 +10,4 @@ $cardHeight?: number;

theme?: Theme;
}>>;
export declare const TimelineCardContentWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
}, never>;
export declare const TimelineCardContentWrapper: import("styled-components").StyledComponent<"div", any, {
$alternateCards?: boolean;

@@ -291,4 +18,4 @@ $cardLess?: boolean;

height?: number;
}>>;
export declare const TimelineTitleWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
}, never>;
export declare const TimelineTitleWrapper: import("styled-components").StyledComponent<"div", any, {
$alternateCards?: boolean;

@@ -298,2 +25,2 @@ $flip?: boolean;

mode?: TimelineMode;
}>>;
}, never>;

1

dist/components/timeline/timeline.d.ts

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { TimelineModel } from '@models/TimelineModel';

@@ -2,0 +3,0 @@ import 'focus-visible';

295

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

@@ -1,10 +0,8 @@

/// <reference types="react" />
/// <reference types="react" />
import { Theme } from '@models/Theme';
import { TimelineMode } from '@models/TimelineModel';
export declare const Wrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
export declare const Wrapper: import("styled-components").StyledComponent<"div", any, {
$hideControls?: boolean;
cardPositionHorizontal?: 'TOP' | 'BOTTOM';
}>>;
export declare const TimelineMainWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
}, never>;
export declare const TimelineMainWrapper: import("styled-components").StyledComponent<"div", any, {
$scrollable?: boolean | {

@@ -15,285 +13,14 @@ scrollbar: boolean;

theme?: Theme;
}>>;
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;
}, never>;
export declare const TimelineMain: import("styled-components").StyledComponent<"div", any, {}, never>;
export declare const Outline: import("styled-components").StyledComponent<"div", any, {
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;
}>>;
export declare const TimelineControlContainer: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
}, never>;
export declare const TimelineControlContainer: import("styled-components").StyledComponent<"div", any, {
active?: boolean;
mode?: TimelineMode;
}>>;
export declare const TimelineContentRender: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
}, never>;
export declare const TimelineContentRender: import("styled-components").StyledComponent<"div", any, {
$showAllCards?: boolean;
}>>;
}, never>;

3

dist/models/TimelineCardTitleModel.d.ts
import { Theme } from './Theme';
/**
* Represents the model for a title element.
*/
export interface TitleModel {

@@ -3,0 +6,0 @@ active?: boolean;

4

dist/models/TimelineContentModel.d.ts

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { ReactNode } from 'react';

@@ -5,2 +6,5 @@ import { Theme } from './Theme';

import { Media } from './TimelineMediaModel';
/**
* Represents the model for timeline content.
*/
export type TimelineContentModel = {

@@ -7,0 +11,0 @@ active?: boolean;

3

dist/models/TimelineControlModel.d.ts

@@ -0,1 +1,4 @@

/**
* Represents the model for controlling the timeline.
*/
export interface TimelineControlModel {

@@ -2,0 +5,0 @@ activeTimelineItem?: number;

4

dist/models/TimelineHorizontalModel.d.ts

@@ -0,4 +1,8 @@

/// <reference types="@types/react" />
import { ReactNode } from 'react';
import { TimelineCardModel } from './TimelineItemModel';
import { TimelineMode } from './TimelineModel';
/**
* Represents the model for a horizontal timeline.
*/
export interface TimelineHorizontalModel {

@@ -5,0 +9,0 @@ autoScroll: (t: Partial<Scroll>) => void;

9

dist/models/TimelineItemModel.d.ts

@@ -0,1 +1,2 @@

/// <reference types="@types/react" />
import { ReactNode } from 'react';

@@ -7,6 +8,3 @@ import { Theme } from './Theme';

/**
*
*
* @export
* @interface TimelineItemModel
* Represents the model for a timeline item.
*/

@@ -31,2 +29,5 @@ export interface TimelineItemModel {

}
/**
* Represents the model for a timeline card.
*/
export type TimelineCardModel = Pick<TimelineItemModel, 'id' | 'visible' | 'title' | 'active' | 'cardDetailedText' | 'cardSubtitle' | 'cardTitle' | 'media' | 'url' | 'timelineContent' | 'isNested' | 'items'> & {

@@ -33,0 +34,0 @@ autoScroll?: ({ pointOffset, pointWidth, timelinePointHeight, contentHeight, }: Partial<Scroll>) => void;

16

dist/models/TimelineMediaModel.d.ts

@@ -0,5 +1,12 @@

/// <reference types="@types/react" />
import { ForwardRefExoticComponent, ReactNode } from 'react';
import { Theme } from './Theme';
import { TextOrContentModel } from '../components/timeline-elements/timeline-card-content/text-or-content';
/**
* Represents the type of media (video or image).
*/
export type MediaType = 'VIDEO' | 'IMAGE';
/**
* Represents the source of a media element.
*/
export interface MediaSource {

@@ -9,2 +16,5 @@ type?: string;

}
/**
* Represents the model for media content.
*/
export interface Media {

@@ -15,2 +25,5 @@ name?: string;

}
/**
* Represents the state of media playback.
*/
export interface MediaState {

@@ -21,2 +34,5 @@ id?: string;

}
/**
* Represents the model for media within a card.
*/
export interface CardMediaModel {

@@ -23,0 +39,0 @@ active?: boolean;

6

dist/models/TimelineModel.d.ts

@@ -1,2 +0,2 @@

/// <reference types="react" />
/// <reference types="@types/react" />
import { Theme } from './Theme';

@@ -89,3 +89,5 @@ import { TimelineItemModel } from './TimelineItemModel';

noUniqueId?: boolean;
onItemSelected?: (data: TimelineItemModel) => void;
onItemSelected?: (data: Pick<TimelineItemModel, 'title' | 'cardDetailedText' | 'cardSubtitle' | 'cardTitle'> & {
index: number;
}) => void;
onRestartSlideshow?: () => void;

@@ -92,0 +94,0 @@ onScrollEnd?: () => void;

14

dist/models/TimelineVerticalModel.d.ts

@@ -1,2 +0,2 @@

/// <reference types="react" />
/// <reference types="@types/react" />
import { Theme } from './Theme';

@@ -7,2 +7,5 @@ import { Scroll } from './TimelineHorizontalModel';

import { TimelineProps } from './TimelineModel';
/**
* Represents the props for the timeline component.
*/
export type Props = Pick<TimelineProps, 'flipLayout' | 'theme' | 'mode' | 'timelinePointDimension' | 'lineWidth' | 'cardHeight' | 'enableOutline' | 'disableClickOnCircle' | 'cardLess' | 'nestedCardHeight'> & {

@@ -22,2 +25,5 @@ alternateCards?: boolean;

};
/**
* Represents the model for a vertical timeline point.
*/
export type TimelinePointModel = Omit<VerticalModel, 'timelineContent'> & {

@@ -27,2 +33,5 @@ iconChild?: React.ReactNode;

};
/**
* Represents the model for a vertical timeline item.
*/
export interface VerticalItemModel extends VerticalModel {

@@ -38,2 +47,5 @@ contentDetailsChildren?: React.ReactNode;

}
/**
* Represents the model for a vertical timeline.
*/
export type TimelineVerticalModel = Pick<Props, 'alternateCards' | 'enableOutline' | 'mode' | 'onClick' | 'onElapsed' | 'slideShowRunning' | 'theme' | 'hasFocus' | 'cardLess' | 'nestedCardHeight'> & {

@@ -40,0 +52,0 @@ activeTimelineItem?: number;

105

dist/README.md

@@ -11,3 +11,3 @@ <div align="center">

[![react-chrono](https://img.shields.io/endpoint?url=https://dashboard.cypress.io/badge/simple/8zb5a5&style=flat&logo=cypress)](https://dashboard.cypress.io/projects/8zb5a5/runs)
![Snyk Vulnerabilities for GitHub Repo](https://img.shields.io/snyk/vulnerabilities/github/prabhuignoto/react-chrono?style=flat)
[![Known Vulnerabilities](https://snyk.io/test/github/prabhuignoto/react-chrono/badge.svg)](https://snyk.io/test/github/prabhuignoto/react-chrono)
[![Depfu](https://badges.depfu.com/badges/48a23a6a830309649b7e516467cd9a48/overview.svg)](https://depfu.com/github/prabhuignoto/react-chrono?project_id=15325)

@@ -19,3 +19,4 @@ ![npm bundle size](https://img.shields.io/bundlephobia/minzip/react-chrono)

![npm downloads](https://img.shields.io/npm/dm/react-chrono.svg?label=npm%20downloads&style=flat)
<a href="https://5f985eb478dcb00022cfd60e-uiaufmxbhf.chromatic.com/?path=/story/example-vertical--vertical-basic" target="_blank"><img src="https://raw.githubusercontent.com/storybooks/brand/master/badge/badge-storybook.svg"></a>
<a href="https://5f985eb478dcb00022cfd60e-hqwgomhkqw.chromatic.com/?path=/story/example-vertical--vertical-basic" target="_blank"><img src="https://raw.githubusercontent.com/storybooks/brand/master/badge/badge-storybook.svg"></a>
[![Coverage Status](https://coveralls.io/repos/github/prabhuignoto/react-chrono/badge.svg?branch=master)](https://coveralls.io/github/prabhuignoto/react-chrono?branch=master)

@@ -152,48 +153,50 @@ <div>

| Name | Default | Description |
| :----------------------- | :------------------- | :------------------------------------------------------------------------------------------------------------------------------- |
| activeItemIndex | 0 | Selects the active timeline item on load. |
| allowDynamicUpdate | false | Allows dynamic updating of timeline items. |
| borderLessCards | false | Removes border and shadow from timeline cards. |
| buttonTexts | | Customize the alt text for all buttons. |
| cardHeight | 200 | Sets the minimum height of timeline cards. |
| cardLess | false | Disables timeline cards in both horizontal and vertical modes. |
| cardPositionHorizontal | | Positions the card in horizontal mode. Can be `TOP` or `BOTTOM`. |
| cardWidth | | Sets the maximum width of timeline cards. |
| classNames | | Applies custom class names for different card elements. |
| contentDetailsHeight | 150 | Controls height of details section if using cardDetailedText. Refer to [TimelineItem model](#timeline-item-model) for more info. |
| disableAutoScrollOnClick | false | Disables auto-scrolling when a timeline card is clicked. |
| disableClickOnCircle | false | Disables click action on circular points. |
| disableNavOnKey | false | Disables keyboard navigation. |
| enableBreakPoint | true | Enables automatic switch to vertical mode when vertical breakpoint is reached. |
| enableDarkToggle | false | Enables toggle switch for dark mode. |
| enableOutline | false | Enables outline menu on vertical and vertical alternating modes. |
| flipLayout | false | Flips the layout (RTL). |
| focusActiveItemOnLoad | false | Automatically scrolls and focuses on the `activeItemIndex` on load. |
| fontSizes | | Customizes font sizes. |
| hideControls | false | Hides navigation controls. |
| itemWidth | 300 | Sets width of timeline section in horizontal mode. |
| items | [] | Collection of Timeline Item Models. |
| lineWidth | 3px | Customizes width of timeline track line. |
| mediaHeight | 200 | Sets minimum height of media element if image or video is embedded in card. |
| mediaSettings | | Configures media-specific layout settings. Refer to [mediaSettings](#media-settings) for more info. |
| mode | VERTICAL_ALTERNATING | Sets component mode. Can be `HORIZONTAL`, `VERTICAL`, or `VERTICAL_ALTERNATING`. |
| nestedCardHeight | 150 | Sets height of nested timeline card. |
| noUniqueId | false | Disables generating a unique id for the table wrapper |
| onItemSelected | | Invokes callback on item selection and passes relevant data. |
| onScrollEnd | | Detects end of timeline via `onScrollEnd`. |
| onThemeChange | | Invokes callback when theme is changed. Triggered via `enableDarkToggle`. |
| scrollable | true | Makes timeline scrollable in `VERTICAL` and `VERTICAL` alternating modes. |
| showAllCardsHorizontal | false | Displays all cards in horizontal mode. By default, only active card is displayed. |
| slideItemDuration | 5000 | Duration in ms that timeline card is active during a slideshow. |
| slideShow | false | Enables slideshow control. |
| textOverlay | false | Displays text as overlay on media elements. Refer to [Text Overlay](#text-overlay-mode) for more info. |
| theme | | Customizes colors. Refer to [Theme](#theme) for more info. |
| timelinePointDimension | | Dimensions of circular points on timeline. |
| timelinePointShape | circle | Configures shape of timeline points. Can be circle, square, or diamond. |
| titleDateFormat | 'MMM DD, YYYY' | Date format used when date is passed for each timeline item. Supports all [dayjs](https://day.js.org/) formats. |
| uniqueId | | This prop should be used in conjunction with `noUniqueId` to pass a custom uniqueId for the wrapper |
| useReadMore | true | Enables or disables "read more" button. Button only available if text content on card is taller than card itself. |
| verticalBreakPoint | 768px | Number of pixels below which timeline will automatically switch to `VERTICAL` mode. |
Below are the available configuration options for the component:
| Name | Default | Description |
| :----------------------- | :------------------- | :--------------------------------------------------------------------------------------------------------------------------------------- |
| activeItemIndex | 0 | Selects the active timeline item when loading. |
| allowDynamicUpdate | false | Enables or disables dynamic updates of timeline items. |
| borderLessCards | false | Removes borders and shadows from the timeline cards. |
| buttonTexts | | Customizes the alternative text for all buttons. |
| cardHeight | 200 | Defines the minimum height of timeline cards. |
| cardLess | false | Disables timeline cards in both horizontal and vertical layouts. |
| cardPositionHorizontal | | Positions the card in horizontal mode. Options: `TOP` or `BOTTOM`. |
| cardWidth | | Sets the maximum width of timeline cards. |
| classNames | | Applies custom class names to different card elements. |
| contentDetailsHeight | 150 | Controls the height of the details section if using cardDetailedText. Refer to [TimelineItem model](#timeline-item-model) for more info. |
| disableAutoScrollOnClick | false | Prevents auto-scrolling when a timeline card is clicked. |
| disableClickOnCircle | false | Disables the click action on circular points. |
| disableNavOnKey | false | Turns off keyboard navigation. |
| enableBreakPoint | true | Automatically switches to vertical mode when the vertical breakpoint is reached. |
| enableDarkToggle | false | Adds a toggle switch for dark mode. |
| enableOutline | false | Enables an outline menu in vertical and vertical alternating modes. |
| flipLayout | false | Reverses the layout (Right to Left). |
| focusActiveItemOnLoad | false | Automatically scrolls to and focuses on the `activeItemIndex` when loading. |
| fontSizes | | Allows customization of font sizes. |
| hideControls | false | Hides navigation controls. |
| itemWidth | 300 | Sets the width of the timeline section in horizontal mode. |
| items | [] | A collection of Timeline Item Models. |
| lineWidth | 3px | Adjusts the width of the timeline track line. |
| mediaHeight | 200 | Sets the minimum height for media elements like images or videos in the card. |
| mediaSettings | | Configures settings specific to media layout. Refer to [mediaSettings](#media-settings) for more info. |
| mode | VERTICAL_ALTERNATING | Sets the component mode. Options: `HORIZONTAL`, `VERTICAL`, `VERTICAL_ALTERNATING`. |
| nestedCardHeight | 150 | Defines the height of nested timeline cards. |
| noUniqueId | false | Prevents generating a unique id for the table wrapper. |
| onItemSelected | | Invokes a callback on item selection, passing relevant data. |
| onScrollEnd | | Detects the end of the timeline via `onScrollEnd`. |
| onThemeChange | | Invokes a callback when the theme changes, triggered via `enableDarkToggle`. |
| scrollable | true | Makes the timeline scrollable in `VERTICAL` and `VERTICAL_ALTERNATING` modes. |
| showAllCardsHorizontal | false | Displays all cards in horizontal mode. By default, only the active card is shown. |
| slideItemDuration | 5000 | Sets the duration (in milliseconds) that a timeline card is active during a slideshow. |
| slideShow | false | Enables slideshow control. |
| textOverlay | false | Displays text as an overlay on media elements. Refer to [Text Overlay](#text-overlay-mode) for more info. |
| theme | | Customizes colors. Refer to [Theme](#theme) for more info. |
| timelinePointDimension | | Defines the dimensions of circular points on the timeline. |
| timelinePointShape | circle | Configures the shape of timeline points. Options: circle, square, diamond. |
| titleDateFormat | 'MMM DD, YYYY' | Formats the date for each timeline item. Supports all [dayjs](https://day.js.org/) formats. |
| uniqueId | | Used with `noUniqueId` to set a custom unique id for the wrapper. |
| useReadMore | true | Enables or disables the "read more" button. Available if text content on the card is taller than the card itself. |
| verticalBreakPoint | 768px | Sets the pixel count below which the timeline will switch to `VERTICAL` mode. |
### Mode

@@ -358,5 +361,3 @@

function MyTimeline() {
return (
<Chrono items={items} textOverlay />
);
return <Chrono items={items} textOverlay />;
}

@@ -621,4 +622,4 @@ ```

- [Horizontal Collection](https://5f985eb478dcb00022cfd60e-wfennyutax.chromatic.com/?path=/story/example-horizontal--horizontal-timeline)
- [Vertical Collection](https://5f985eb478dcb00022cfd60e-wfennyutax.chromatic.com/?path=/story/example-vertical--vertical-basic)
- [Horizontal Collection](https://5f985eb478dcb00022cfd60e-hqwgomhkqw.chromatic.com/?path=/story/example-horizontal--horizontal-timeline)
- [Vertical Collection](https://5f985eb478dcb00022cfd60e-hqwgomhkqw.chromatic.com/?path=/story/example-vertical--vertical-basic)

@@ -625,0 +626,0 @@ ## 🔨Build Setup

88

package.json
{
"name": "react-chrono",
"version": "2.2.4",
"version": "2.2.5",
"license": "MIT",

@@ -56,34 +56,36 @@ "description": "A Modern Timeline component for React",

"devDependencies": {
"@babel/core": "^7.22.9",
"@babel/core": "^7.22.19",
"@babel/plugin-proposal-optional-chaining": "^7.21.0",
"@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",
"@babel/plugin-transform-runtime": "^7.22.15",
"@babel/plugin-transform-typescript": "^7.22.15",
"@babel/preset-env": "^7.22.15",
"@babel/preset-react": "^7.22.15",
"@babel/preset-typescript": "^7.22.15",
"@emotion/babel-plugin": "^11.11.0",
"@jest/types": "^29.6.1",
"@jest/types": "^29.6.3",
"@rollup/plugin-babel": "^6.0.3",
"@rollup/plugin-buble": "^1.0.2",
"@rollup/plugin-commonjs": "^25.0.3",
"@rollup/plugin-node-resolve": "^15.1.0",
"@rollup/plugin-commonjs": "^25.0.4",
"@rollup/plugin-node-resolve": "^15.2.1",
"@rollup/plugin-strip": "^3.0.2",
"@rollup/plugin-terser": "^0.4.3",
"@size-limit/preset-big-lib": "^8.2.6",
"@size-limit/preset-big-lib": "^9.0.0",
"@stylelint/postcss-css-in-js": "^0.38.0",
"@testing-library/dom": "^9.3.1",
"@testing-library/jest-dom": "^5.17.0",
"@testing-library/jest-dom": "^6.1.3",
"@testing-library/react": "^14.0.0",
"@testing-library/user-event": "^14.4.3",
"@types/jest": "^29.5.3",
"@types/node": "^20.4.7",
"@types/react": "^18.2.18",
"@testing-library/react-hooks": "^8.0.1",
"@testing-library/user-event": "^14.5.1",
"@types/jest": "^29.5.5",
"@types/node": "^20.6.2",
"@types/react": "^18.2.21",
"@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.9",
"@typescript-eslint/eslint-plugin": "^6.2.1",
"@typescript-eslint/parser": "^6.2.1",
"@types/styled-components": "^5.1.27",
"@types/testing-library__jest-dom": "^6.0.0",
"@typescript-eslint/eslint-plugin": "^6.7.0",
"@typescript-eslint/parser": "^6.7.0",
"@vitejs/plugin-react": "^4.0.4",
"@vitest/coverage-v8": "^0.34.1",
"autoprefixer": "^10.4.14",
"@vitest/coverage-v8": "^0.34.4",
"autoprefixer": "^10.4.15",
"babel-loader": "^9.1.3",

@@ -93,17 +95,17 @@ "babel-plugin-styled-components": "^2.1.4",

"cssnano": "^6.0.1",
"cypress": "12.17.3",
"eslint": "^8.46.0",
"eslint-config-prettier": "^8.10.0",
"eslint-plugin-import": "^2.28.0",
"cypress": "13.2.0",
"eslint": "^8.49.0",
"eslint-config-prettier": "^9.0.0",
"eslint-plugin-import": "^2.28.1",
"eslint-plugin-jsx-a11y": "^6.7.1",
"eslint-plugin-react": "^7.33.1",
"eslint-plugin-react": "^7.33.2",
"eslint-plugin-sort-keys-fix": "^1.1.2",
"eslint-plugin-typescript-sort-keys": "^2.3.0",
"eslint-plugin-typescript-sort-keys": "^3.0.0",
"husky": "^8.0.3",
"jsdom": "^22.1.0",
"lint-staged": "^13.2.3",
"postcss": "^8.4.27",
"postcss-preset-env": "^9.1.0",
"lint-staged": "^14.0.1",
"postcss": "^8.4.29",
"postcss-preset-env": "^9.1.3",
"postcss-syntax": "^0.36.2",
"prettier": "^3.0.1",
"prettier": "^3.0.3",
"pretty-quick": "^3.1.3",

@@ -113,7 +115,7 @@ "react": "^18.2.0",

"react-is": "^18.2.0",
"react-router-dom": "^6.14.2",
"react-router-dom": "^6.16.0",
"rimraf": "^5.0.1",
"rollup": "^3.27.2",
"rollup": "^3.29.2",
"rollup-plugin-analyzer": "^4.0.0",
"rollup-plugin-copy": "^3.4.0",
"rollup-plugin-copy": "^3.5.0",
"rollup-plugin-delete": "^2.0.0",

@@ -124,8 +126,8 @@ "rollup-plugin-peer-deps-external": "^2.2.4",

"rollup-plugin-typescript2": "^0.35.0",
"sass": "^1.64.2",
"sass": "^1.67.0",
"semver": "^7.5.4",
"size-limit": "^8.2.6",
"snyk": "^1.1200.0",
"size-limit": "^9.0.0",
"snyk": "^1.1220.0",
"start-server-and-test": "^2.0.0",
"stylelint": "^15.10.2",
"stylelint": "^15.10.3",
"stylelint-config-recommended": "^13.0.0",

@@ -135,6 +137,6 @@ "stylelint-config-styled-components": "^0.1.1",

"stylelint-processor-styled-components": "^1.10.0",
"typescript": "^5.1.6",
"vite": "^4.4.8",
"vite-tsconfig-paths": "^4.2.0",
"vitest": "^0.34.1"
"typescript": "^5.2.2",
"vite": "^4.4.9",
"vite-tsconfig-paths": "^4.2.1",
"vitest": "^0.34.4"
},

@@ -141,0 +143,0 @@ "resolutions": {

105

README.md

@@ -11,3 +11,3 @@ <div align="center">

[![react-chrono](https://img.shields.io/endpoint?url=https://dashboard.cypress.io/badge/simple/8zb5a5&style=flat&logo=cypress)](https://dashboard.cypress.io/projects/8zb5a5/runs)
![Snyk Vulnerabilities for GitHub Repo](https://img.shields.io/snyk/vulnerabilities/github/prabhuignoto/react-chrono?style=flat)
[![Known Vulnerabilities](https://snyk.io/test/github/prabhuignoto/react-chrono/badge.svg)](https://snyk.io/test/github/prabhuignoto/react-chrono)
[![Depfu](https://badges.depfu.com/badges/48a23a6a830309649b7e516467cd9a48/overview.svg)](https://depfu.com/github/prabhuignoto/react-chrono?project_id=15325)

@@ -19,3 +19,4 @@ ![npm bundle size](https://img.shields.io/bundlephobia/minzip/react-chrono)

![npm downloads](https://img.shields.io/npm/dm/react-chrono.svg?label=npm%20downloads&style=flat)
<a href="https://5f985eb478dcb00022cfd60e-uiaufmxbhf.chromatic.com/?path=/story/example-vertical--vertical-basic" target="_blank"><img src="https://raw.githubusercontent.com/storybooks/brand/master/badge/badge-storybook.svg"></a>
<a href="https://5f985eb478dcb00022cfd60e-hqwgomhkqw.chromatic.com/?path=/story/example-vertical--vertical-basic" target="_blank"><img src="https://raw.githubusercontent.com/storybooks/brand/master/badge/badge-storybook.svg"></a>
[![Coverage Status](https://coveralls.io/repos/github/prabhuignoto/react-chrono/badge.svg?branch=master)](https://coveralls.io/github/prabhuignoto/react-chrono?branch=master)

@@ -152,48 +153,50 @@ <div>

| Name | Default | Description |
| :----------------------- | :------------------- | :------------------------------------------------------------------------------------------------------------------------------- |
| activeItemIndex | 0 | Selects the active timeline item on load. |
| allowDynamicUpdate | false | Allows dynamic updating of timeline items. |
| borderLessCards | false | Removes border and shadow from timeline cards. |
| buttonTexts | | Customize the alt text for all buttons. |
| cardHeight | 200 | Sets the minimum height of timeline cards. |
| cardLess | false | Disables timeline cards in both horizontal and vertical modes. |
| cardPositionHorizontal | | Positions the card in horizontal mode. Can be `TOP` or `BOTTOM`. |
| cardWidth | | Sets the maximum width of timeline cards. |
| classNames | | Applies custom class names for different card elements. |
| contentDetailsHeight | 150 | Controls height of details section if using cardDetailedText. Refer to [TimelineItem model](#timeline-item-model) for more info. |
| disableAutoScrollOnClick | false | Disables auto-scrolling when a timeline card is clicked. |
| disableClickOnCircle | false | Disables click action on circular points. |
| disableNavOnKey | false | Disables keyboard navigation. |
| enableBreakPoint | true | Enables automatic switch to vertical mode when vertical breakpoint is reached. |
| enableDarkToggle | false | Enables toggle switch for dark mode. |
| enableOutline | false | Enables outline menu on vertical and vertical alternating modes. |
| flipLayout | false | Flips the layout (RTL). |
| focusActiveItemOnLoad | false | Automatically scrolls and focuses on the `activeItemIndex` on load. |
| fontSizes | | Customizes font sizes. |
| hideControls | false | Hides navigation controls. |
| itemWidth | 300 | Sets width of timeline section in horizontal mode. |
| items | [] | Collection of Timeline Item Models. |
| lineWidth | 3px | Customizes width of timeline track line. |
| mediaHeight | 200 | Sets minimum height of media element if image or video is embedded in card. |
| mediaSettings | | Configures media-specific layout settings. Refer to [mediaSettings](#media-settings) for more info. |
| mode | VERTICAL_ALTERNATING | Sets component mode. Can be `HORIZONTAL`, `VERTICAL`, or `VERTICAL_ALTERNATING`. |
| nestedCardHeight | 150 | Sets height of nested timeline card. |
| noUniqueId | false | Disables generating a unique id for the table wrapper |
| onItemSelected | | Invokes callback on item selection and passes relevant data. |
| onScrollEnd | | Detects end of timeline via `onScrollEnd`. |
| onThemeChange | | Invokes callback when theme is changed. Triggered via `enableDarkToggle`. |
| scrollable | true | Makes timeline scrollable in `VERTICAL` and `VERTICAL` alternating modes. |
| showAllCardsHorizontal | false | Displays all cards in horizontal mode. By default, only active card is displayed. |
| slideItemDuration | 5000 | Duration in ms that timeline card is active during a slideshow. |
| slideShow | false | Enables slideshow control. |
| textOverlay | false | Displays text as overlay on media elements. Refer to [Text Overlay](#text-overlay-mode) for more info. |
| theme | | Customizes colors. Refer to [Theme](#theme) for more info. |
| timelinePointDimension | | Dimensions of circular points on timeline. |
| timelinePointShape | circle | Configures shape of timeline points. Can be circle, square, or diamond. |
| titleDateFormat | 'MMM DD, YYYY' | Date format used when date is passed for each timeline item. Supports all [dayjs](https://day.js.org/) formats. |
| uniqueId | | This prop should be used in conjunction with `noUniqueId` to pass a custom uniqueId for the wrapper |
| useReadMore | true | Enables or disables "read more" button. Button only available if text content on card is taller than card itself. |
| verticalBreakPoint | 768px | Number of pixels below which timeline will automatically switch to `VERTICAL` mode. |
Below are the available configuration options for the component:
| Name | Default | Description |
| :----------------------- | :------------------- | :--------------------------------------------------------------------------------------------------------------------------------------- |
| activeItemIndex | 0 | Selects the active timeline item when loading. |
| allowDynamicUpdate | false | Enables or disables dynamic updates of timeline items. |
| borderLessCards | false | Removes borders and shadows from the timeline cards. |
| buttonTexts | | Customizes the alternative text for all buttons. |
| cardHeight | 200 | Defines the minimum height of timeline cards. |
| cardLess | false | Disables timeline cards in both horizontal and vertical layouts. |
| cardPositionHorizontal | | Positions the card in horizontal mode. Options: `TOP` or `BOTTOM`. |
| cardWidth | | Sets the maximum width of timeline cards. |
| classNames | | Applies custom class names to different card elements. |
| contentDetailsHeight | 150 | Controls the height of the details section if using cardDetailedText. Refer to [TimelineItem model](#timeline-item-model) for more info. |
| disableAutoScrollOnClick | false | Prevents auto-scrolling when a timeline card is clicked. |
| disableClickOnCircle | false | Disables the click action on circular points. |
| disableNavOnKey | false | Turns off keyboard navigation. |
| enableBreakPoint | true | Automatically switches to vertical mode when the vertical breakpoint is reached. |
| enableDarkToggle | false | Adds a toggle switch for dark mode. |
| enableOutline | false | Enables an outline menu in vertical and vertical alternating modes. |
| flipLayout | false | Reverses the layout (Right to Left). |
| focusActiveItemOnLoad | false | Automatically scrolls to and focuses on the `activeItemIndex` when loading. |
| fontSizes | | Allows customization of font sizes. |
| hideControls | false | Hides navigation controls. |
| itemWidth | 300 | Sets the width of the timeline section in horizontal mode. |
| items | [] | A collection of Timeline Item Models. |
| lineWidth | 3px | Adjusts the width of the timeline track line. |
| mediaHeight | 200 | Sets the minimum height for media elements like images or videos in the card. |
| mediaSettings | | Configures settings specific to media layout. Refer to [mediaSettings](#media-settings) for more info. |
| mode | VERTICAL_ALTERNATING | Sets the component mode. Options: `HORIZONTAL`, `VERTICAL`, `VERTICAL_ALTERNATING`. |
| nestedCardHeight | 150 | Defines the height of nested timeline cards. |
| noUniqueId | false | Prevents generating a unique id for the table wrapper. |
| onItemSelected | | Invokes a callback on item selection, passing relevant data. |
| onScrollEnd | | Detects the end of the timeline via `onScrollEnd`. |
| onThemeChange | | Invokes a callback when the theme changes, triggered via `enableDarkToggle`. |
| scrollable | true | Makes the timeline scrollable in `VERTICAL` and `VERTICAL_ALTERNATING` modes. |
| showAllCardsHorizontal | false | Displays all cards in horizontal mode. By default, only the active card is shown. |
| slideItemDuration | 5000 | Sets the duration (in milliseconds) that a timeline card is active during a slideshow. |
| slideShow | false | Enables slideshow control. |
| textOverlay | false | Displays text as an overlay on media elements. Refer to [Text Overlay](#text-overlay-mode) for more info. |
| theme | | Customizes colors. Refer to [Theme](#theme) for more info. |
| timelinePointDimension | | Defines the dimensions of circular points on the timeline. |
| timelinePointShape | circle | Configures the shape of timeline points. Options: circle, square, diamond. |
| titleDateFormat | 'MMM DD, YYYY' | Formats the date for each timeline item. Supports all [dayjs](https://day.js.org/) formats. |
| uniqueId | | Used with `noUniqueId` to set a custom unique id for the wrapper. |
| useReadMore | true | Enables or disables the "read more" button. Available if text content on the card is taller than the card itself. |
| verticalBreakPoint | 768px | Sets the pixel count below which the timeline will switch to `VERTICAL` mode. |
### Mode

@@ -358,5 +361,3 @@

function MyTimeline() {
return (
<Chrono items={items} textOverlay />
);
return <Chrono items={items} textOverlay />;
}

@@ -621,4 +622,4 @@ ```

- [Horizontal Collection](https://5f985eb478dcb00022cfd60e-wfennyutax.chromatic.com/?path=/story/example-horizontal--horizontal-timeline)
- [Vertical Collection](https://5f985eb478dcb00022cfd60e-wfennyutax.chromatic.com/?path=/story/example-vertical--vertical-basic)
- [Horizontal Collection](https://5f985eb478dcb00022cfd60e-hqwgomhkqw.chromatic.com/?path=/story/example-horizontal--horizontal-timeline)
- [Vertical Collection](https://5f985eb478dcb00022cfd60e-hqwgomhkqw.chromatic.com/?path=/story/example-vertical--vertical-basic)

@@ -625,0 +626,0 @@ ## 🔨Build Setup

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

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc