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.7 to 2.3.0

2

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

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

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

1

dist/components/GlobalContext.d.ts

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

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

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

1

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

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

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

1

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

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

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

1

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

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

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

1

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

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

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

1

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

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

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

1

dist/components/index.d.ts

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

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

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

1

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

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

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

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

1

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

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

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

@@ -3,0 +2,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").Keyframes;
export declare const slideInFromTop: import("styled-components").Keyframes;
export declare const slideInFromLeft: import("styled-components").Keyframes;
export declare const slideFromRight: import("styled-components").Keyframes;
export declare const reveal: import("styled-components/dist/models/Keyframes").default;
export declare const slideInFromTop: import("styled-components/dist/models/Keyframes").default;
export declare const slideInFromLeft: import("styled-components/dist/models/Keyframes").default;
export declare const slideFromRight: import("styled-components/dist/models/Keyframes").default;

1

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

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

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

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

1

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

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

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

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

1

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

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

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

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

1

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

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

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

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

1

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

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

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

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

1

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

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

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

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

596

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

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

/// <reference types="react" />
/// <reference types="react" />
import { Theme } from '@models/Theme';
import { TimelineProps } from '@models/TimelineModel';
type ContentT = Pick<TimelineProps, 'theme' | 'slideShow' | 'mode' | 'borderLessCards'>;
export declare const TimelineItemContentWrapper: import("styled-components").StyledComponent<"section", any, {
export declare const TimelineItemContentWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, {
$active?: boolean;

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

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

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

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

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

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

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

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

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

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

283

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

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

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

1

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

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

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

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

863

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

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

/// <reference types="react" />
/// <reference types="react" />
import { Theme } from '@models/Theme';
import { TimelineMode } from '@models/TimelineModel';
export declare const linearGradient: import("styled-components").FlattenSimpleInterpolation;
export declare const MediaWrapper: import("styled-components").StyledComponent<"div", any, {
export declare const linearGradient: import("styled-components").RuleSet<object>;
export declare const MediaWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
$active?: boolean;

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

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

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

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

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

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

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

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

1

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

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

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

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

1

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

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

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

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

863

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

@@ -0,23 +1,860 @@

/// <reference types="react" />
/// <reference types="react" />
import { Theme } from '@models/Theme';
import { TimelineMode } from '@models/TimelineModel';
export declare const TimelineNavWrapper: import("styled-components").StyledComponent<"ul", any, {
export declare const TimelineNavWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, {
theme?: Theme;
}, never>;
export declare const TimelineNavItem: import("styled-components").StyledComponent<"li", any, {
}>>;
export declare const TimelineNavItem: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, {
$disable?: boolean;
}, never>;
export declare const TimelineNavButton: import("styled-components").StyledComponent<"button", any, {
}>>;
export declare const TimelineNavButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
mode?: TimelineMode;
rotate?: 'TRUE' | 'FALSE';
theme?: Theme;
}, never>;
export declare const TimelineControlContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
export declare const ControlButton: import("styled-components").StyledComponent<"button", any, {
}>>;
export declare const TimelineControlContainer: import("styled-components").IStyledComponent<"web", {
ref?: import("react").LegacyRef<HTMLDivElement>;
key?: import("react").Key;
defaultChecked?: boolean;
defaultValue?: string | number | readonly string[];
suppressContentEditableWarning?: boolean;
suppressHydrationWarning?: boolean;
accessKey?: string;
autoFocus?: boolean;
className?: string;
contentEditable?: (boolean | "true" | "false") | "inherit";
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?: "text" | "search" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
is?: string;
'aria-activedescendant'?: string;
'aria-atomic'?: boolean | "true" | "false";
'aria-autocomplete'?: "list" | "none" | "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'?: "link" | "none" | "copy" | "execute" | "move" | "popup";
'aria-errormessage'?: string;
'aria-expanded'?: boolean | "true" | "false";
'aria-flowto'?: string;
'aria-grabbed'?: boolean | "true" | "false";
'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree";
'aria-hidden'?: boolean | "true" | "false";
'aria-invalid'?: boolean | "true" | "false" | "grammar" | "spelling";
'aria-keyshortcuts'?: string;
'aria-label'?: string;
'aria-labelledby'?: string;
'aria-level'?: number;
'aria-live'?: "off" | "assertive" | "polite";
'aria-modal'?: boolean | "true" | "false";
'aria-multiline'?: boolean | "true" | "false";
'aria-multiselectable'?: boolean | "true" | "false";
'aria-orientation'?: "horizontal" | "vertical";
'aria-owns'?: string;
'aria-placeholder'?: string;
'aria-posinset'?: number;
'aria-pressed'?: boolean | "true" | "false" | "mixed";
'aria-readonly'?: boolean | "true" | "false";
'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
'aria-required'?: boolean | "true" | "false";
'aria-roledescription'?: string;
'aria-rowcount'?: number;
'aria-rowindex'?: number;
'aria-rowindextext'?: string;
'aria-rowspan'?: number;
'aria-selected'?: boolean | "true" | "false";
'aria-setsize'?: number;
'aria-sort'?: "none" | "ascending" | "descending" | "other";
'aria-valuemax'?: number;
'aria-valuemin'?: number;
'aria-valuenow'?: number;
'aria-valuetext'?: string;
children?: import("react").ReactNode;
dangerouslySetInnerHTML?: {
__html: string | TrustedHTML;
};
onCopy?: import("react").ClipboardEventHandler<HTMLDivElement>;
onCopyCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
onCut?: import("react").ClipboardEventHandler<HTMLDivElement>;
onCutCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
onPaste?: import("react").ClipboardEventHandler<HTMLDivElement>;
onPasteCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
onCompositionEnd?: import("react").CompositionEventHandler<HTMLDivElement>;
onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
onCompositionStart?: import("react").CompositionEventHandler<HTMLDivElement>;
onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDivElement>;
onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
onFocus?: import("react").FocusEventHandler<HTMLDivElement>;
onFocusCapture?: import("react").FocusEventHandler<HTMLDivElement>;
onBlur?: import("react").FocusEventHandler<HTMLDivElement>;
onBlurCapture?: import("react").FocusEventHandler<HTMLDivElement>;
onChange?: import("react").FormEventHandler<HTMLDivElement>;
onChangeCapture?: import("react").FormEventHandler<HTMLDivElement>;
onBeforeInput?: import("react").FormEventHandler<HTMLDivElement>;
onBeforeInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
onInput?: import("react").FormEventHandler<HTMLDivElement>;
onInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
onReset?: import("react").FormEventHandler<HTMLDivElement>;
onResetCapture?: import("react").FormEventHandler<HTMLDivElement>;
onSubmit?: import("react").FormEventHandler<HTMLDivElement>;
onSubmitCapture?: import("react").FormEventHandler<HTMLDivElement>;
onInvalid?: import("react").FormEventHandler<HTMLDivElement>;
onInvalidCapture?: import("react").FormEventHandler<HTMLDivElement>;
onLoad?: import("react").ReactEventHandler<HTMLDivElement>;
onLoadCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onError?: import("react").ReactEventHandler<HTMLDivElement>;
onErrorCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onKeyDown?: import("react").KeyboardEventHandler<HTMLDivElement>;
onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
onKeyPress?: import("react").KeyboardEventHandler<HTMLDivElement>;
onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
onKeyUp?: import("react").KeyboardEventHandler<HTMLDivElement>;
onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
onAbort?: import("react").ReactEventHandler<HTMLDivElement>;
onAbortCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onCanPlay?: import("react").ReactEventHandler<HTMLDivElement>;
onCanPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onCanPlayThrough?: import("react").ReactEventHandler<HTMLDivElement>;
onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onDurationChange?: import("react").ReactEventHandler<HTMLDivElement>;
onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onEmptied?: import("react").ReactEventHandler<HTMLDivElement>;
onEmptiedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onEncrypted?: import("react").ReactEventHandler<HTMLDivElement>;
onEncryptedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onEnded?: import("react").ReactEventHandler<HTMLDivElement>;
onEndedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onLoadedData?: import("react").ReactEventHandler<HTMLDivElement>;
onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onLoadedMetadata?: import("react").ReactEventHandler<HTMLDivElement>;
onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onLoadStart?: import("react").ReactEventHandler<HTMLDivElement>;
onLoadStartCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onPause?: import("react").ReactEventHandler<HTMLDivElement>;
onPauseCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onPlay?: import("react").ReactEventHandler<HTMLDivElement>;
onPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onPlaying?: import("react").ReactEventHandler<HTMLDivElement>;
onPlayingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onProgress?: import("react").ReactEventHandler<HTMLDivElement>;
onProgressCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onRateChange?: import("react").ReactEventHandler<HTMLDivElement>;
onRateChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onResize?: import("react").ReactEventHandler<HTMLDivElement>;
onResizeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onSeeked?: import("react").ReactEventHandler<HTMLDivElement>;
onSeekedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onSeeking?: import("react").ReactEventHandler<HTMLDivElement>;
onSeekingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onStalled?: import("react").ReactEventHandler<HTMLDivElement>;
onStalledCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onSuspend?: import("react").ReactEventHandler<HTMLDivElement>;
onSuspendCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onTimeUpdate?: import("react").ReactEventHandler<HTMLDivElement>;
onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onVolumeChange?: import("react").ReactEventHandler<HTMLDivElement>;
onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onWaiting?: import("react").ReactEventHandler<HTMLDivElement>;
onWaitingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onAuxClick?: import("react").MouseEventHandler<HTMLDivElement>;
onAuxClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
onClick?: import("react").MouseEventHandler<HTMLDivElement>;
onClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
onContextMenu?: import("react").MouseEventHandler<HTMLDivElement>;
onContextMenuCapture?: import("react").MouseEventHandler<HTMLDivElement>;
onDoubleClick?: import("react").MouseEventHandler<HTMLDivElement>;
onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
onDrag?: import("react").DragEventHandler<HTMLDivElement>;
onDragCapture?: import("react").DragEventHandler<HTMLDivElement>;
onDragEnd?: import("react").DragEventHandler<HTMLDivElement>;
onDragEndCapture?: import("react").DragEventHandler<HTMLDivElement>;
onDragEnter?: import("react").DragEventHandler<HTMLDivElement>;
onDragEnterCapture?: import("react").DragEventHandler<HTMLDivElement>;
onDragExit?: import("react").DragEventHandler<HTMLDivElement>;
onDragExitCapture?: import("react").DragEventHandler<HTMLDivElement>;
onDragLeave?: import("react").DragEventHandler<HTMLDivElement>;
onDragLeaveCapture?: import("react").DragEventHandler<HTMLDivElement>;
onDragOver?: import("react").DragEventHandler<HTMLDivElement>;
onDragOverCapture?: import("react").DragEventHandler<HTMLDivElement>;
onDragStart?: import("react").DragEventHandler<HTMLDivElement>;
onDragStartCapture?: import("react").DragEventHandler<HTMLDivElement>;
onDrop?: import("react").DragEventHandler<HTMLDivElement>;
onDropCapture?: import("react").DragEventHandler<HTMLDivElement>;
onMouseDown?: import("react").MouseEventHandler<HTMLDivElement>;
onMouseDownCapture?: import("react").MouseEventHandler<HTMLDivElement>;
onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement>;
onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement>;
onMouseMove?: import("react").MouseEventHandler<HTMLDivElement>;
onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDivElement>;
onMouseOut?: import("react").MouseEventHandler<HTMLDivElement>;
onMouseOutCapture?: import("react").MouseEventHandler<HTMLDivElement>;
onMouseOver?: import("react").MouseEventHandler<HTMLDivElement>;
onMouseOverCapture?: import("react").MouseEventHandler<HTMLDivElement>;
onMouseUp?: import("react").MouseEventHandler<HTMLDivElement>;
onMouseUpCapture?: import("react").MouseEventHandler<HTMLDivElement>;
onSelect?: import("react").ReactEventHandler<HTMLDivElement>;
onSelectCapture?: import("react").ReactEventHandler<HTMLDivElement>;
onTouchCancel?: import("react").TouchEventHandler<HTMLDivElement>;
onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDivElement>;
onTouchEnd?: import("react").TouchEventHandler<HTMLDivElement>;
onTouchEndCapture?: import("react").TouchEventHandler<HTMLDivElement>;
onTouchMove?: import("react").TouchEventHandler<HTMLDivElement>;
onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDivElement>;
onTouchStart?: import("react").TouchEventHandler<HTMLDivElement>;
onTouchStartCapture?: import("react").TouchEventHandler<HTMLDivElement>;
onPointerDown?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerDownCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerMove?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerUp?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerUpCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerCancel?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerEnter?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerEnterCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerLeave?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerOver?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerOverCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerOut?: import("react").PointerEventHandler<HTMLDivElement>;
onPointerOutCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onGotPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onLostPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
onScroll?: import("react").UIEventHandler<HTMLDivElement>;
onScrollCapture?: import("react").UIEventHandler<HTMLDivElement>;
onWheel?: import("react").WheelEventHandler<HTMLDivElement>;
onWheelCapture?: import("react").WheelEventHandler<HTMLDivElement>;
onAnimationStart?: import("react").AnimationEventHandler<HTMLDivElement>;
onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
onAnimationEnd?: import("react").AnimationEventHandler<HTMLDivElement>;
onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
onAnimationIteration?: import("react").AnimationEventHandler<HTMLDivElement>;
onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
onTransitionEnd?: import("react").TransitionEventHandler<HTMLDivElement>;
onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDivElement>;
}>;
export declare const ControlButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
theme?: Theme;
}, never>;
export declare const MediaToggle: import("styled-components").StyledComponent<"button", any, {
}>>;
export declare const MediaToggle: import("styled-components").IStyledComponent<"web", {
theme?: Theme;
}, never>;
export declare const ReplayWrapper: import("styled-components").StyledComponent<"button", any, {
key?: import("react").Key;
value?: string | number | readonly string[];
defaultChecked?: boolean;
defaultValue?: string | number | readonly string[];
suppressContentEditableWarning?: boolean;
suppressHydrationWarning?: boolean;
accessKey?: string;
autoFocus?: boolean;
className?: string;
contentEditable?: (boolean | "true" | "false") | "inherit";
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?: "text" | "search" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
is?: string;
'aria-activedescendant'?: string;
'aria-atomic'?: boolean | "true" | "false";
'aria-autocomplete'?: "list" | "none" | "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'?: "link" | "none" | "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>;
}> & import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
theme?: Theme;
}, never>;
}>>;
export declare const ReplayWrapper: import("styled-components").IStyledComponent<"web", {
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?: (boolean | "true" | "false") | "inherit";
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?: "text" | "search" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
is?: string;
'aria-activedescendant'?: string;
'aria-atomic'?: boolean | "true" | "false";
'aria-autocomplete'?: "list" | "none" | "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'?: "link" | "none" | "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>;
}> & import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
theme?: Theme;
}>>;

1

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

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

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

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

5

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

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

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

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

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

1

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

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

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

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

1

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

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

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

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

569

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

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

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

1

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

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

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

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

9

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

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

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

1

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

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

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

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

1

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

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

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

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

279

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

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

export declare const TimelinePointWrapper: import("styled-components").StyledComponent<"div", any, {
/// <reference types="react" />
/// <reference types="react" />
export declare const TimelinePointWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
$cardLess?: boolean;
bg?: string;
width?: number;
}, never>;
export declare const TimelinePointContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
}>>;
export declare const TimelinePointContainer: import("styled-components").IStyledComponent<"web", {
ref?: import("react").LegacyRef<HTMLDivElement>;
key?: import("react").Key;
defaultChecked?: boolean;
defaultValue?: string | number | readonly string[];
suppressContentEditableWarning?: boolean;
suppressHydrationWarning?: boolean;
accessKey?: string;
autoFocus?: boolean;
className?: string;
contentEditable?: (boolean | "true" | "false") | "inherit";
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'?: "list" | "none" | "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'?: "link" | "none" | "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>;
}>;

1

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

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

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

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

287

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

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

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

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

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

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

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

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

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

1

dist/components/timeline/timeline.d.ts

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

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

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

295

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

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

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

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

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

1

dist/models/TimelineContentModel.d.ts

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

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

@@ -3,0 +2,0 @@ import { Theme } from './Theme';

1

dist/models/TimelineHorizontalModel.d.ts

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

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

@@ -3,0 +2,0 @@ import { TimelineCardModel } from './TimelineItemModel';

1

dist/models/TimelineItemModel.d.ts

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

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

@@ -3,0 +2,0 @@ import { Theme } from './Theme';

1

dist/models/TimelineMediaModel.d.ts

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

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

@@ -3,0 +2,0 @@ import { Theme } from './Theme';

2

dist/models/TimelineModel.d.ts

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

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

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

2

dist/models/TimelineVerticalModel.d.ts

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

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

@@ -3,0 +3,0 @@ import { Scroll } from './TimelineHorizontalModel';

29

package.json
{
"name": "react-chrono",
"version": "2.2.7",
"version": "2.3.0",
"license": "MIT",

@@ -43,5 +43,6 @@ "description": "A Modern Timeline component for React",

"classnames": "^2.3.2",
"dayjs": "^1.11.9",
"dayjs": "^1.11.10",
"focus-visible": "^5.2.0",
"styled-components": "=5.3.10"
"styled-components": "^6.0.8",
"stylis": "^4.3.0"
},

@@ -80,3 +81,3 @@ "peerDependencies": {

"@types/jest": "^29.5.5",
"@types/node": "^20.6.2",
"@types/node": "^20.6.5",
"@types/react": "^18.2.22",

@@ -89,5 +90,5 @@ "@types/react-dom": "^18.2.7",

"@typescript-eslint/parser": "^6.7.2",
"@vitejs/plugin-react": "^4.0.4",
"@vitest/coverage-v8": "^0.34.4",
"autoprefixer": "^10.4.15",
"@vitejs/plugin-react": "^4.1.0",
"@vitest/coverage-v8": "^0.34.5",
"autoprefixer": "^10.4.16",
"babel-loader": "^9.1.3",

@@ -98,3 +99,3 @@ "babel-plugin-styled-components": "^2.1.4",

"cypress": "13.2.0",
"eslint": "^8.49.0",
"eslint": "^8.50.0",
"eslint-config-prettier": "^9.0.0",

@@ -119,3 +120,3 @@ "eslint-plugin-import": "^2.28.1",

"rimraf": "^5.0.1",
"rollup": "^3.29.2",
"rollup": "^3.29.3",
"rollup-plugin-analyzer": "^4.0.0",

@@ -126,9 +127,8 @@ "rollup-plugin-copy": "^3.5.0",

"rollup-plugin-postcss": "^4.0.2",
"rollup-plugin-terser": "^7.0.2",
"rollup-plugin-typescript2": "^0.35.0",
"sass": "^1.67.0",
"sass": "^1.68.0",
"semver": "^7.5.4",
"size-limit": "^9.0.0",
"snyk": "^1.1223.0",
"start-server-and-test": "^2.0.0",
"snyk": "^1.1226.0",
"start-server-and-test": "^2.0.1",
"stylelint": "^15.10.3",

@@ -140,5 +140,6 @@ "stylelint-config-recommended": "^13.0.0",

"typescript": "^5.2.2",
"typescript-plugin-styled-components": "^3.0.0",
"vite": "^4.4.9",
"vite-tsconfig-paths": "^4.2.1",
"vitest": "^0.34.4"
"vitest": "^0.34.5"
},

@@ -145,0 +146,0 @@ "resolutions": {

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