import * as Cesium from 'cesium'; /** Pick a round epoch near startMs so tick offsets are clean integers (mirrors Cesium). */ export declare function calcEpochMs(startMs: number, durationSec: number, timezone?: string): number; /** * Clamp a single point in time to optional hard limits. * Used to keep the current-time needle from advancing past `restrictToRange` * bounds (e.g. during playback) — either limit may be omitted. */ export declare function clampMsToLimits(ms: number, limitStartMs?: number, limitEndMs?: number): number; /** * Clamp a visible range so it never extends past the given hard limits. * Used to enforce scroll/zoom boundaries (see `restrictToRange`). * * When the visible span is wider than the limit span, the range collapses to * the full limit span (i.e. zooming out stops at the limits). Otherwise the * range is shifted (not resized) so it fits entirely within the limits. * Either limit may be omitted to leave that side unrestricted. */ export declare function clampRangeToLimits(startMs: number, endMs: number, limitStartMs?: number, limitEndMs?: number): { startMs: number; endMs: number; }; /** Clamp a time span to the allowed zoom range. */ export declare function clampSpan(span: number): number; /** * Framework-agnostic base props for the transport controls. */ export declare interface ControlsBaseProps { /** The current time displayed in the control bar (ms since epoch). */ currentTimeMs: number; /** Whether playback is currently active. */ isPlaying: boolean; /** Current playback speed multiplier (negative = rewind). */ multiplier: number; /** @see TimelineBaseProps.dateTimeFormat */ dateTimeFormat?: string; /** @see TimelineBaseProps.timezone */ timezone?: string; /** @see TimelineBaseProps.onDateTimeClick */ onDateTimeClick?: () => void; /** Toggle play / pause. */ onPlayPause: (isPlaying: boolean) => void; /** Jump to the start of the timeline range. */ onJumpToStart: () => void; /** Step to the next rewind speed. */ onRewind: () => void; /** Step to the next fast-forward speed. */ onFastForward: () => void; /** Jump to the end of the timeline range. */ onJumpToEnd: () => void; /** Jump to the current wall-clock time and resume 1× playback. */ onJumpToLive: () => void; /** Reset the playback speed to 1×. */ onResetSpeed: () => void; /** Set the playback speed to an explicit absolute value (current direction is preserved). */ onSetSpeed: (value: number) => void; /** @see TimelineBaseProps.minSpeed */ minSpeed?: number; /** @see TimelineBaseProps.maxSpeed */ maxSpeed?: number; /** Whether the needle is near the current wall-clock time (within 2 s). */ isLive: boolean; /** Whether to enable the ⏮ jump-to-start button (true when startTime prop was provided). */ hasStartTime: boolean; /** Whether to enable the ⏭ jump-to-end button (true when endTime prop was provided). */ hasEndTime: boolean; /** Whether to show the ⏮ jump-to-start button at all. @default true */ showJumpToStart?: boolean; /** Whether to show the ⏭ jump-to-end button at all. @default true */ showJumpToEnd?: boolean; /** Resolved theme object applied to control bar elements. */ theme: TimelineTheme; /** Whether swim lanes are currently visible. When defined, the chevron toggle is rendered. */ swimLanesVisible?: boolean; /** Toggle callback for the swim-lane chevron button. */ onToggleSwimLanes?: () => void; /** * Overrides for control-bar labels and tooltips. * @see TimelineBaseProps.labels */ labels?: Partial; /** @see TimelineBaseProps.liveButtonSize */ liveButtonSize?: 'sm' | 'md' | 'lg'; /** @see TimelineBaseProps.liveButtonPosition */ liveButtonPosition?: 'left' | 'right'; /** @see TimelineBaseProps.showLive */ showLive?: boolean; } /** Decomposed date/time fields extracted in a specific timezone. `mo` is 0-indexed. */ export declare interface DateParts { yr: number; mo: number; day: number; hr24: number; hr12: number; min: number; sec: number; ms: number; ampm: 'AM' | 'PM'; } /** Built-in format presets. Pass one of these (or any custom string) as `dateTimeFormat`. */ export declare const DateTimeFormats: { /** e.g. "Feb 24 2026 14:04:07" — default */ readonly DEFAULT: "MMM DD YYYY HH:mm:ss"; /** e.g. "Feb 24 2026 02:04:07 PM" */ readonly TWELVE_HR: "MMM DD YYYY hh:mm:ss A"; /** e.g. "2026-02-24 14:04:07" */ readonly ISO: "YYYY-MM-DD HH:mm:ss"; /** e.g. "02/24/2026 14:04" */ readonly US: "MM/DD/YYYY HH:mm"; /** e.g. "24/02/2026 14:04" */ readonly EU: "DD/MM/YYYY HH:mm"; /** e.g. "14:04:07" */ readonly TIME_ONLY: "HH:mm:ss"; /** e.g. "02:04:07 PM" */ readonly TIME_12: "hh:mm:ss A"; }; /** English default labels — used as the fallback for any field not overridden. */ export declare const DEFAULT_LABELS: Required; export declare const DEFAULT_LANE_HEIGHT = 24; export declare const defaultSwimLaneStyle: SwimLaneStyle; export declare const defaultTheme: TimelineTheme; /** * Render the entire timeline onto a 2D canvas context. * * This is a pure rendering function — it reads from `state` and writes pixels * to `ctx`. It does NOT modify `state` (except returning clamped scrollTop * if the caller wants to update it). * * @param ctx The 2D rendering context (already DPR-scaled by the caller). * @param w CSS-pixel width of the canvas. * @param h CSS-pixel height of the canvas. * @param state The current render state. * @returns The clamped scrollTop value (caller should update their state if different). */ export declare function drawTimeline(ctx: CanvasRenderingContext2D, w: number, h: number, state: TimelineRenderState): number; /** * Format a date using a token-based format string. * * Supported tokens (longest-first to avoid partial matches): * YYYY – 4-digit year e.g. 2026 * YY – 2-digit year e.g. 26 * MMMM – full month name e.g. February * MMM – abbreviated month name e.g. Feb * MM – zero-padded month number e.g. 02 * M – month number e.g. 2 * DD – zero-padded day e.g. 05 * D – day e.g. 5 * HH – 24-hour, zero-padded e.g. 14 * H – 24-hour e.g. 14 * hh – 12-hour, zero-padded e.g. 02 * h – 12-hour e.g. 2 * mm – minutes, zero-padded e.g. 04 * ss – seconds, zero-padded e.g. 07 * SSS – milliseconds, zero-padded e.g. 042 * A – AM / PM uppercase * a – am / pm lowercase */ export declare function formatDateTime(date: Cesium.JulianDate | Date, format?: string, timezone?: string): string; /** @deprecated Use formatDateTime instead */ export declare function formatTime(date: Cesium.JulianDate | Date, includeSeconds?: boolean): string; export declare function fromMilliseconds(ms: number): Cesium.JulianDate; export declare function generateTicks(startTime: Cesium.JulianDate | Date, endTime: Cesium.JulianDate | Date, tickInterval: TickInterval | number, width: number): Tick[]; /** * Extract date/time components in the given timezone. * When `timezone` is `undefined` or `'local'`, the browser's local time methods are used. * Otherwise, `Intl.DateTimeFormat#formatToParts` is used for timezone-accurate extraction. */ export declare function getDateParts(date: Date, timezone?: string): DateParts; export declare function getDurationMs(startTime: Cesium.JulianDate | Date, endTime: Cesium.JulianDate | Date): number; /** * Return the short timezone abbreviation for the given date in the given timezone, * e.g. `"UTC"`, `"EST"`, `"PDT"`. Returns `null` when timezone is `undefined` or `'local'`. */ export declare function getTimezoneAbbr(date: Cesium.JulianDate | Date, timezone?: string): string | null; /** Check if a Y coordinate is in the swim lane label area (leftmost ~80px). */ export declare function hitTestLaneLabel(canvasX: number, canvasY: number, canvasH: number, state: Pick): SwimLane | null; /** * Given canvas-local coordinates, find which swim lane item (if any) is under the point. */ export declare function hitTestSwimLane(canvasX: number, canvasY: number, canvasW: number, canvasH: number, state: Pick): SwimLaneHitResult | null; /** Check if Y is in the swim lane region (above tick area). */ export declare function isInSwimLaneRegion(canvasY: number, canvasH: number, state: Pick): boolean; /** Left padding in pixels for lane labels. */ export declare const LABEL_PAD_LEFT = 6; /** Gap in pixels between swim lane rows. */ export declare const LANE_GAP = 1; export declare function makeLabel(ms: number, durationSec: number, timezone?: string, use12h?: boolean, months?: string[]): string; /** Maximum visible span: ~1 000 years — stays within TIC_SCALES range. */ export declare const MAX_SPAN_MS = 31536000000000; /** Minimum visible span: 1 second — prevents sub-ms span / blank canvas. */ export declare const MIN_SPAN_MS = 1000; /** Abbreviated month names used for tick labels. */ export declare const MONTHS: string[]; /** Advance to next tick boundary (identical to Cesium's getNextTic). */ export declare function nextTic(t: number, scale: number): number; export declare function positionToTime(x: number, startTime: Cesium.JulianDate | Date, endTime: Cesium.JulianDate | Date, width: number): Cesium.JulianDate; /** Drag-to-reorder visual state. */ export declare interface ReorderState { dragging: boolean; dragLaneId: string; dragStartY: number; currentY: number; insertIndex: number; } /** Resolve the effective style for a swim lane item (item → lane → theme → defaults). */ export declare function resolveItemStyle(lane: SwimLane, item: SwimLaneItem, theme?: TimelineTheme): SwimLaneItemStyle; /** Resolves a label field that may be a static string or a multiplier callback. */ export declare function resolveLabel(label: string | ((multiplier: number) => string), multiplier: number): string; /** Width in pixels for the thin scrollbar track. */ export declare const SCROLLBAR_WIDTH = 6; export declare function snapToTick(x: number, ticks: Tick[], snapDistance?: number): number; /** * Split a format string into separate time and date parts for two-line display. * Strips date tokens to derive the time format, and time tokens to derive the date format. * Returns empty string for either part if no relevant tokens exist in the format. */ export declare function splitForDisplay(format?: string): { timeFormat: string; dateFormat: string; }; /** Multiplier applied to wheel deltaY for swim lane vertical scrolling. * Keeps scrolling smooth when the overflow range is small. */ export declare const SWIM_LANE_SCROLL_SPEED = 0.3; export declare interface SwimLane { id: string; label: string; items: SwimLaneItem[]; /** Lane-level default style applied to all items unless overridden per-item. */ style?: Partial; /** Height of this lane row in pixels. @default 24 */ height?: number; } export declare interface SwimLaneEventInfo { laneId: string; item: SwimLaneItem; originalEvent: MouseEvent; } /** Hit-test result for swim lane items. */ export declare interface SwimLaneHitResult { lane: SwimLane; item: SwimLaneItem; } export declare interface SwimLaneItem { id: string; /** Provide a TimeInterval for a range (bar). */ interval?: Cesium.TimeInterval; /** Provide a JulianDate for a point-in-time (marker). */ instant?: Cesium.JulianDate; /** Per-item style overrides. */ style?: Partial; /** Arbitrary user data attached to this item. */ data?: unknown; } export declare interface SwimLaneItemStyle { /** Fill color for interval bars / instant markers. */ color: string; /** Border color for interval bars. */ borderColor: string; /** Border width in pixels. */ borderWidth: number; /** Opacity (0–1). */ opacity: number; /** Shape used to render instants. */ markerShape: 'diamond' | 'circle' | 'line'; /** Size in pixels for instant markers. */ markerSize: number; } export declare interface SwimLaneStyle extends SwimLaneItemStyle { /** Color of the lane label text. */ labelColor: string; /** Background color of the lane row. */ backgroundColor: string; } /** * Cesium-derived tick scale table (in seconds). * Used to pick appropriate major / sub / tiny tick intervals. */ export declare const TIC_SCALES: number[]; export declare interface Tick { position: number; isMajor: boolean; label?: string; } /** Fixed height in pixels for the tick + label area at the bottom of the canvas. */ export declare const TICK_AREA_HEIGHT = 36; export declare enum TickInterval { FIFTEEN_MIN = 15, THIRTY_MIN = 30, HOURLY = 60, CUSTOM = -1 } /** * Framework-agnostic base props for the timeline component. * Framework wrappers (React, Angular) extend or adapt this interface. */ export declare interface TimelineBaseProps { /** The start boundary of the timeline range. Defaults to 12 hours before now. */ startTime?: Cesium.JulianDate | Date; /** The end boundary of the timeline range. Defaults to 12 hours after now. */ endTime?: Cesium.JulianDate | Date; /** Initial current-time position of the needle. Defaults to `startTime` or now. */ currentTime?: Cesium.JulianDate | Date; /** Cesium Clock instance to synchronize with. When provided the timeline follows the clock's tick. */ clock?: Cesium.Clock; /** Fired whenever the current time changes (scrub, playback, or programmatic jump). */ onTimeChange?: (time: Cesium.JulianDate) => void; /** Fired when playback is toggled. Receives the new playing state. */ onPlayPause?: (isPlaying: boolean) => void; /** Fired when the playback speed multiplier changes (fast-forward / rewind). */ onMultiplierChange?: (multiplier: number) => void; /** * Explicit height in pixels. When omitted the timeline fills its container * (the outer div uses `height: 100%`). When provided, a fixed pixel height * is applied instead. */ height?: number; /** Tick interval override. When omitted the timeline auto-selects an appropriate scale. */ tickInterval?: TickInterval | number; /** Whether to render tick labels on the time axis. @default true */ showLabels?: boolean; /** Whether to render the transport control bar above the canvas. @default true */ showControls?: boolean; /** Whether to show the ⏮ jump-to-start button in the control bar. @default true */ showJumpToStart?: boolean; /** Whether to show the ⏭ jump-to-end button in the control bar. @default true */ showJumpToEnd?: boolean; /** When `true`, ticks snap to round time boundaries during scrub. */ snapToTicks?: boolean; /** Whether the user can scrub / drag the timeline. @default true */ enableDrag?: boolean; /** * Format string for the time display in the control bar. * Tokens: YYYY YY MMMM MMM MM M DD D HH H hh h mm ss SSS A a * Presets available via the exported `DateTimeFormats` object. * @default 'MMM DD YYYY HH:mm:ss' */ dateTimeFormat?: string; /** * Called when the user clicks the datetime display in the control bar. * Use this to open your own date/time picker. */ onDateTimeClick?: () => void; /** * Set this to a new Date or JulianDate to programmatically jump the timeline * to that moment (pans the canvas and updates current time). */ jumpToTime?: Cesium.JulianDate | Date; /** * Maximum number of major ticks to render on the canvas at one time. * When the computed tick count would exceed this value the tick scale is * coarsened until it fits. Defaults to unlimited. */ maxTicks?: number; /** * Speed steps cycled by the fast-forward button. * Each click advances to the next entry; the last entry wraps back to the * first. Defaults to [2, 4, 8, 16, 32, 1]. */ ffSpeeds?: number[]; /** * Absolute-value speed steps cycled by the rewind button (negated internally). * Defaults to [1, 2, 4, 8, 16, 32]. */ rwSpeeds?: number[]; /** * Lower bound of the slider/input in the playback-speed overlay (opened by * clicking the speed badge). Direction (forward/rewind) is preserved. * @default 1 */ minSpeed?: number; /** * Upper bound of the slider/input in the playback-speed overlay. * @default 100 */ maxSpeed?: number; /** * IANA timezone string used for all datetime display on the timeline. * Examples: `'UTC'`, `'America/New_York'`, `'Europe/London'`. * Use `'local'` (default) to use the browser's local timezone. * When set to a value other than `'local'`, a timezone abbreviation label * (e.g. "UTC", "EST", "PDT") is shown to the right of the date display. */ timezone?: string; /** Partial theme overrides merged with the default theme. */ theme?: Partial; /** * Swim lane definitions. Each lane is a labeled row rendered inside the * timeline canvas showing time intervals (bars) and/or instants (markers). */ swimLanes?: SwimLane[]; /** * Whether to show swim lanes. Defaults to `true` when `swimLanes` is provided. * When `swimLanes` is provided, a chevron toggle button in the control bar * lets the user expand / collapse the lanes at runtime. */ showSwimLanes?: boolean; /** * Fired when the built-in swim-lane toggle button is clicked. * Receives the new visibility value. Use this to keep external state in sync. */ onShowSwimLanesChange?: (visible: boolean) => void; /** * Transition used when the timeline expands / collapses swim lanes. * `'animated'` applies a smooth CSS transition (default). * `'instant'` switches height immediately with no animation. */ swimLaneTransition?: 'animated' | 'instant'; /** Fired when the user clicks a swim lane item. */ onSwimLaneItemClick?: (info: SwimLaneEventInfo) => void; /** Fired when the user hovers over (or leaves) a swim lane item. `null` = left. */ onSwimLaneItemHover?: (info: SwimLaneEventInfo | null) => void; /** Fired when the user double-clicks a swim lane item. */ onSwimLaneItemDoubleClick?: (info: SwimLaneEventInfo) => void; /** Fired when the user right-clicks a swim lane item. */ onSwimLaneItemContextMenu?: (info: SwimLaneEventInfo) => void; /** Fired when swim lanes are reordered via drag. Returns the new ordered lane IDs. */ onSwimLaneReorder?: (orderedLaneIds: string[]) => void; /** * Overrides for control-bar labels and tooltips. * Useful for localisation or custom verbiage — provide only the strings you * want to change; everything else falls back to the English defaults. */ labels?: Partial; /** * Size of the LIVE button in the control bar. * `'sm'` is compact, `'md'` is the default, `'lg'` is prominent. * @default 'md' */ liveButtonSize?: 'sm' | 'md' | 'lg'; /** * Which side of the control bar the LIVE button appears on. * `'left'` places it beside the datetime display (default). * `'right'` moves it to the right side of the control bar. * @default 'left' */ liveButtonPosition?: 'left' | 'right'; /** * Whether to show the LIVE button in the control bar. * @default true */ showLive?: boolean; /** * When `true`, the timeline is locked to live mode. * Needle drag, datetime click, play/pause, rewind, fast-forward, * jump-to-start, and jump-to-end are all disabled. The LIVE button * becomes a non-interactive status indicator. Canvas zoom and pan * remain fully interactive. */ live?: boolean; /** * When `true`, reverses the scroll-wheel zoom direction so that * scrolling down zooms in on time and scrolling up zooms out. * By default (false) scrolling up zooms in and scrolling down zooms out. * @default false */ invertScrollZoom?: boolean; /** * When `true`, `startTime` and `endTime` become hard scroll/zoom limits: * the user cannot pan or zoom the visible window past them (drag, wheel, * pinch, edge-scroll, and range-select are all clamped). Has no effect * unless `startTime` and/or `endTime` are provided. * @default false */ restrictToRange?: boolean; } /** * All user-facing labels and tooltip strings rendered by the timeline control bar. * Every field is optional — provide only the strings you want to override. * Unspecified fields fall back to the English defaults in {@link DEFAULT_LABELS}. * * Dynamic tooltip fields accept either a static string **or** a function that * receives the current speed multiplier and returns a string, letting you embed * the value in whatever format your language requires. * * @example * ```ts * // Minimal French override * const frLabels: Partial = { * playTooltip: 'Lecture', * pauseTooltip: 'Pause', * liveTooltip: 'Aller en direct', * liveActiveTooltip: 'En direct', * }; * * ``` */ export declare interface TimelineLabels { /** Tooltip shown on the datetime display when `onDateTimeClick` is wired up. */ dateTimeClickTooltip: string; /** Visible text on the LIVE button when the needle is NOT at live time. */ liveLabel: string; /** Visible text on the LIVE button when the needle IS at live time. */ liveActiveLabel: string; /** Tooltip when the needle is NOT at live time. */ liveTooltip: string; /** Tooltip when the needle IS at live time. */ liveActiveTooltip: string; /** * Tooltip on the speed badge (shown when playback is not 1×). * Clicking the badge opens the playback-speed overlay (slider + input). */ resetSpeedTooltip: string; /** Heading shown at the top of the playback-speed overlay. */ speedOverlayTitle: string; /** Shared aria-label for the overlay's slider and number input. */ speedInputLabel: string; /** Visible text on the reset button inside the playback-speed overlay. */ resetSpeedLabel: string; /** Tooltip on the reset button inside the playback-speed overlay. */ resetSpeedTitle: string; /** Tooltip on the ⏮ jump-to-start button when a start time is set. */ jumpToStartTooltip: string; /** Tooltip on the ⏮ jump-to-start button when no start time is set. */ noStartTimeTooltip: string; /** Tooltip on the ⏭ jump-to-end button when an end time is set. */ jumpToEndTooltip: string; /** Tooltip on the ⏭ jump-to-end button when no end time is set. */ noEndTimeTooltip: string; /** Tooltip on the ◀◀ rewind button when not currently rewinding. */ rewindTooltip: string; /** * Tooltip on the ◀◀ rewind button while actively rewinding. * Receives the current absolute multiplier (e.g. `2`, `4`, `8`). */ rewindActiveTooltip: string | ((multiplier: number) => string); /** Tooltip on the play button when stopped and not rewinding. */ playTooltip: string; /** Tooltip on the play button when rewinding (clicking will reset to 1× forward). */ playFromRewindTooltip: string; /** Tooltip on the play button when currently playing (will pause on click). */ pauseTooltip: string; /** Tooltip on the ▶▶ fast-forward button when at normal speed. */ fastForwardTooltip: string; /** * Tooltip on the ▶▶ fast-forward button while fast-forwarding. * Receives the current absolute multiplier (e.g. `2`, `4`, `8`). */ fastForwardActiveTooltip: string | ((multiplier: number) => string); /** Tooltip on the chevron button when swim lanes are currently visible (click will collapse). */ collapseSwimLanesTooltip: string; /** Tooltip on the chevron button when swim lanes are currently hidden (click will expand). */ expandSwimLanesTooltip: string; /** * Abbreviated month names used for timeline tick labels (Jan–Dec zoom levels). * Provide all 12 entries in calendar order (January first) to translate the * month labels shown on the canvas. * * @example * ```ts * // French * months: ['Jan', 'Fév', 'Mar', 'Avr', 'Mai', 'Jun', * 'Jul', 'Aoû', 'Sep', 'Oct', 'Nov', 'Déc'] * ``` */ months: [ string, string, string, string, string, string, string, string, string, string, string, string ]; } /** Mutable state the engine reads during a draw call. */ export declare interface TimelineRenderState { startMs: number; endMs: number; currentMs: number; theme: TimelineTheme; maxTicks?: number; swimLanes: SwimLane[]; showSwimLanes: boolean; scrollTop: number; reorderState: ReorderState | null; /** @see TimelineBaseProps.timezone */ timezone?: string; /** When true, tick labels use 12-hour (hh:mm AM/PM) format instead of 24-hour. */ use12h?: boolean; /** Abbreviated month names for tick labels. Falls back to English when omitted. */ months?: string[]; /** * Active range selection (set while the user is dragging to select a range). * When non-null, a highlight is rendered over the selected time span in the tick area. */ rangeSelection?: { startMs: number; endMs: number; } | null; /** * Canvas-relative X position of the cursor (in CSS pixels) while the user is * hovering over the timeline. When non-null a ghost needle is drawn at this * position with 15 % opacity so the user can preview where a click / drag * would land before committing. */ hoverMs?: number | null; } export declare interface TimelineTheme { backgroundColor: string; tickColor: string; majorTickColor: string; labelColor: string; indicatorColor: string; indicatorLineWidth: number; majorTickHeight: number; minorTickHeight: number; fontSize: number; controlBarBackground: string; controlBarBorder: string; buttonColor: string; buttonHoverColor: string; /** Highlight color for active FF/RW buttons. Defaults to indicatorColor. */ buttonActiveColor: string; /** Default border color for swim lane items. */ swimLaneItemBorderColor: string; /** Default border width for swim lane items (px). Set to 0 to remove borders. */ swimLaneItemBorderWidth: number; /** Color of the red dot shown on the LIVE button when playback is live. */ liveDotColor: string; } export declare interface TimePosition { x: number; time: Cesium.JulianDate; } export declare function timeToPosition(time: Cesium.JulianDate | Date, startTime: Cesium.JulianDate | Date, endTime: Cesium.JulianDate | Date, width: number): number; /** Convenience constants for the `timezone` prop. */ export declare const Timezones: { /** Use the browser's local timezone (default behavior). */ readonly LOCAL: "local"; /** Coordinated Universal Time. */ readonly UTC: "UTC"; }; export declare function toDate(date: Cesium.JulianDate | Date): Date; export declare function toJulianDate(date: Cesium.JulianDate | Date): Cesium.JulianDate; export declare function toMilliseconds(date: Cesium.JulianDate | Date): number; /** Compute the total content height of all swim lanes. */ export declare function totalSwimLaneHeight(lanes: SwimLane[]): number; export declare function twoD(n: number): string; /** * Compute a new visible range after zooming by `amount` around a specific * pivot time. The pivot stays at the same fractional position on-screen, * which is the expected behaviour for pinch-to-zoom (pivot = midpoint between * the two fingers) and mouse-wheel zoom anchored to the cursor. */ export declare function zoomAroundMs(startMs: number, endMs: number, amount: number, pivotMs: number): { startMs: number; endMs: number; }; /** Compute a new visible range after zooming by `amount` around the center. */ export declare function zoomRange(startMs: number, endMs: number, amount: number): { startMs: number; endMs: number; }; export { }