/** The state object for one of the components available. */
export declare type ComponentStateJson = {
    BlankSpace: BlankSpaceComponentStateJson;
} | {
    CurrentComparison: CurrentComparisonComponentStateJson;
} | {
    CurrentPace: CurrentPaceComponentStateJson;
} | {
    Delta: DeltaComponentStateJson;
} | {
    DetailedTimer: DetailedTimerComponentStateJson;
} | {
    Graph: GraphComponentStateJson;
} | {
    PossibleTimeSave: PossibleTimeSaveComponentStateJson;
} | {
    PreviousSegment: PreviousSegmentComponentStateJson;
} | {
    Separator: null;
} | {
    Splits: SplitsComponentStateJson;
} | {
    SumOfBest: SumOfBestComponentStateJson;
} | {
    Text: TextComponentStateJson;
} | {
    Timer: TimerComponentStateJson;
} | {
    Title: TitleComponentStateJson;
} | {
    TotalPlaytime: TotalPlaytimeComponentStateJson;
};
/**
 * Colors can be used to describe what color to use for visualizing backgrounds,
 * texts, lines and various other elements that are being shown. They are stored
 * as RGBA colors with float point numbers ranging from 0.0 to 1.0 per channel.
 */
export declare type Color = number[];
/**
 * Describes a Gradient for coloring a region with more than just a single
 * color.
 */
export declare type Gradient = "Transparent" | {
    Plain: Color;
} | {
    Vertical: Color[];
} | {
    Horizontal: Color[];
};
/** Describes the Alignment of the Title in the Title Component. */
export declare type Alignment = "Auto" | "Left" | "Center";
/** The state object describes the information to visualize for the layout. */
export interface LayoutStateJson {
    /** The state objects for all of the components in the layout. */
    components: ComponentStateJson[];
    /** The background to show behind the layout. */
    background: Gradient;
    /** The color of thin separators. */
    thin_separators_color: Color;
    /** The color of normal separators. */
    separators_color: Color;
    /** The text color to use for text that doesn't specify its own color. */
    text_color: Color;
}
/**
 * A Timing Method describes which form of timing is used. This can either be
 * Real Time or Game Time.
 */
export declare enum TimingMethod {
    /**
     * Real Time is the unmodified timing that is as close to an atomic clock as
     * possible.
     */
    RealTime = 0,
    /**
     * Game Time describes the timing that is provided by the game that is being
     * run. This is entirely optional and may either be Real Time with loading
     * times removed or some time provided by the game.
     */
    GameTime = 1
}
/**
 * Describes which phase the timer is currently in. This tells you if there's an
 * active speedrun attempt and whether it is paused or it ended.
 */
export declare enum TimerPhase {
    /** There's currently no active attempt. */
    NotRunning = 0,
    /** There's an active attempt that didn't end yet and isn't paused. */
    Running = 1,
    /** There's an attempt that already ended, but didn't get reset yet. */
    Ended = 2,
    /** There's an active attempt that is currently paused. */
    Paused = 3
}
/** The state object describes the information to visualize for this component. */
export interface BlankSpaceComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /** The height of the component. */
    height: number;
}
/** The state object describes the information to visualize for this component. */
export interface TimerComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /** The time shown by the component without the fractional part. */
    time: string;
    /** The fractional part of the time shown (including the dot). */
    fraction: string;
    /** The semantic coloring information the time carries. */
    semantic_color: SemanticColor;
    /** The top color of the timer's gradient. */
    top_color: Color;
    /** The bottom color of the timer's gradient. */
    bottom_color: Color;
    /** The height of the timer. */
    height: number;
}
/** The state object describes the information to visualize for this component. */
export interface TitleComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /**
     * The color of the text. If `null` is specified, the color is taken from
     * the layout.
     */
    text_color: Color | null;
    /**
     * The game's icon encoded as a Data URL. This value is only specified
     * whenever the icon changes. If you explicitly want to query this value,
     * remount the component. The String itself may be empty. This indicates
     * that there is no icon.
     */
    icon_change: string | null;
    /**
     * The first title line to show. This is either the game's name, or a
     * combination of the game's name and the category.
     */
    line1: string;
    /**
     * By default the category name is shown on the second line. Based on the
     * settings, it can however instead be shown in a single line together with
     * the game name.
     */
    line2: string | null;
    /**
     * Specifies whether the title should centered or aligned to the left
     * instead.
     */
    is_centered: boolean;
    /**
     * The amount of successfully finished attempts. If `null` is specified, the
     * amount of successfully finished attempts isn't supposed to be shown.
     */
    finished_runs: number | null;
    /**
     * The amount of total attempts. If `null` is specified, the amount of total
     * attempts isn't supposed to be shown.
     */
    attempts: number | null;
}
/** The state object describes the information to visualize for this component. */
export interface SplitsComponentStateJson {
    /** The list of all the segments to visualize. */
    splits: SplitStateJson[];
    /**
     * This list describes all the icon changes that happened. Each time a
     * segment is first shown or its icon changes, the new icon is provided in
     * this list. If necessary, you may remount this component to reset the
     * component into a state where these icons are provided again.
     */
    icon_changes: SplitsComponentIconChangeJson[];
    /**
     * Describes whether a more pronounced separator should be shown in front of
     * the last segment provided.
     */
    show_final_separator: boolean;
    /**
     * The gradient to show behind the current segment as an indicator of it
     * being the current segment.
     */
    current_split_gradient: Gradient;
}
/**
 * Describes the icon to be shown for a certain segment. This is provided
 * whenever a segment is first shown or whenever its icon changes. If necessary,
 * you may remount this component to reset the component into a state where
 * these icons are provided again.
 */
export interface SplitsComponentIconChangeJson {
    /**
     * The index of the segment of which the icon changed. This is based on the
     * index in the run, not on the index of the `SplitStateJson` in the
     * `SplitsComponentStateJson` object. The corresponding index is the `index`
     * field of the `SplitStateJson` object.
     */
    segment_index: number;
    /**
     * The segment's icon encoded as a Data URL. The String itself may be empty.
     * This indicates that there is no icon.
     */
    icon: string;
}
/** The state object that describes a single segment's information to visualize. */
export interface SplitStateJson {
    /** The name of the segment. */
    name: string;
    /** The delta to show for this segment. */
    delta: string;
    /** The split time to show for this segment. */
    time: string;
    /** The semantic coloring information the delta time carries. */
    semantic_color: SemanticColor;
    /** The visual color of the delta time. */
    visual_color: Color;
    /**
     * Describes if this segment is the segment the active attempt is currently
     * on.
     */
    is_current_split: boolean;
    /**
     * The index of the segment based on all the segments of the run. This may
     * differ from the index of this `SplitStateJson` in the
     * `SplitsComponentStateJson` object, as there can be a scrolling window,
     * showing only a subset of segments.
     */
    index: number;
}
/** The state object describes the information to visualize for this component. */
export interface PreviousSegmentComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /**
     * The color of the label. If `null` is specified, the color is taken from
     * the layout.
     */
    label_color: Color | null;
    /** The label's text. */
    text: string;
    /** The delta (and possibly the possible time save). */
    time: string;
    /** The semantic coloring information the delta time carries. */
    semantic_color: SemanticColor;
    /** The visual color of the delta time. */
    visual_color: Color;
}
/** The state object describes the information to visualize for this component. */
export interface SumOfBestComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /**
     * The color of the label. If `null` is specified, the color is taken from
     * the layout.
     */
    label_color: Color | null;
    /**
     * The color of the value. If `null` is specified, the color is taken from
     * the layout.
     */
    value_color: Color | null;
    /** The label's text. */
    text: string;
    /** The sum of best segments. */
    time: string;
}
/** The state object describes the information to visualize for this component. */
export interface PossibleTimeSaveComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /**
     * The color of the label. If `null` is specified, the color is taken from
     * the layout.
     */
    label_color: Color | null;
    /**
     * The color of the value. If `null` is specified, the color is taken from
     * the layout.
     */
    value_color: Color | null;
    /** The label's text. */
    text: string;
    /** The current possible time save. */
    time: string;
}
/**
 * The state object describes the information to visualize for this component.
 * All the coordinates are in the range 0..1.
 */
export interface GraphComponentStateJson {
    /**
     * All of the graph's points. Connect all of them to visualize the graph. If
     * the live delta is active, the last point is to be interpreted as a
     * preview of the next split that is about to happen. Use the partial fill
     * color to visualize the region beneath that graph segment.
     */
    points: GraphComponentStatePointJson[];
    /** Contains the y coordinates of all the horizontal grid lines. */
    horizontal_grid_lines: number[];
    /** Contains the x coordinates of all the vertical grid lines. */
    vertical_grid_lines: number[];
    /**
     * The y coordinate that separates the region that shows the times that are
     * ahead of the comparison and those that are behind.
     */
    middle: number;
    /**
     * If the live delta is active, the last point is to be interpreted as a
     * preview of the next split that is about to happen. Use the partial fill
     * color to visualize the region beneath that graph segment.
     */
    is_live_delta_active: boolean;
    /**
     * Describes whether the graph is flipped vertically. For visualizing the
     * graph, this usually doesn't need to be interpreted, as this information
     * is entirely encoded into the other variables.
     */
    is_flipped: boolean;
    /**
     * The background color to use for the top region of the graph. The top
     * region ends at the y coordinate of the middle.
     */
    top_background_color: Color;
    /**
     * The background color to use for the bottom region of the graph. The top
     * region begins at the y coordinate of the middle.
     */
    bottom_background_color: Color;
    /** The color of the grid lines on the graph. */
    grid_lines_color: Color;
    /** The color of the lines connecting all the graph's points. */
    graph_lines_color: Color;
    /**
     * The color of the polygon connecting all the graph's points. The partial
     * fill color is only used for live changes.
     */
    partial_fill_color: Color;
    /** The color of the polygon connecting all the graph's points. */
    complete_fill_color: Color;
    /**
     * The best segment color to use for coloring graph segments that achieved a
     * new best segment time.
     */
    best_segment_color: Color;
    /** The height of the graph. */
    height: number;
}
/** Describes a point on the graph to visualize. */
export interface GraphComponentStatePointJson {
    /** The x coordinate of the point. */
    x: number;
    /** The y coordinate of the point. */
    y: number;
    /**
     * Describes whether the segment this point is visualizing achieved a new
     * best segment time. Use the best segment color for it, in that case.
     */
    is_best_segment: boolean;
}
/** The state object describes the information to visualize for this component. */
export interface TextComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /** The text to show for the component. */
    text: TextComponentStateText;
}
/** The text that is supposed to be shown. */
export declare type TextComponentStateText = {
    Center: string;
} | {
    Split: string[];
};
/** The state object describes the information to visualize for this component. */
export interface TotalPlaytimeComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /**
     * The color of the label. If `null` is specified, the color is taken from
     * the layout.
     */
    label_color: Color | null;
    /**
     * The color of the value. If `null` is specified, the color is taken from
     * the layout.
     */
    value_color: Color | null;
    /** The label's text. */
    text: string;
    /** The total playtime. */
    time: string;
}
/** The state object describes the information to visualize for this component. */
export interface CurrentPaceComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /**
     * The color of the label. If `null` is specified, the color is taken from
     * the layout.
     */
    label_color: Color | null;
    /**
     * The color of the value. If `null` is specified, the color is taken from
     * the layout.
     */
    value_color: Color | null;
    /** The label's text. */
    text: string;
    /** The current pace. */
    time: string;
}
/** The state object describes the information to visualize for this component. */
export interface DeltaComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /**
     * The color of the label. If `null` is specified, the color is taken from
     * the layout.
     */
    label_color: Color | null;
    /** The label's text. */
    text: string;
    /** The delta. */
    time: string;
    /** The semantic coloring information the delta time carries. */
    semantic_color: SemanticColor;
    /** The visual color of the delta time. */
    visual_color: Color;
}
/** The state object describes the information to visualize for this component. */
export interface CurrentComparisonComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /**
     * The color of the label. If `null` is specified, the color is taken from
     * the layout.
     */
    label_color: Color | null;
    /**
     * The color of the value. If `null` is specified, the color is taken from
     * the layout.
     */
    value_color: Color | null;
    /** The label's text. */
    text: string;
    /**
     * The name of the comparison that is currently selected to be compared
     * against.
     */
    comparison: string;
}
/** The state object describes the information to visualize for this component. */
export interface DetailedTimerComponentStateJson {
    /** The background shown behind the component. */
    background: Gradient;
    /** The state of the attempt timer. */
    timer: TimerComponentStateJson;
    /** The state of the segment timer. */
    segment_timer: TimerComponentStateJson;
    /** The first comparison to visualize. */
    comparison1: DetailedTimerComponentComparisonStateJson | null;
    /** The second comparison to visualize. */
    comparison2: DetailedTimerComponentComparisonStateJson | null;
    /**
     * The name of the segment. This may be `null` if it's not supposed to be
     * visualized.
     */
    segment_name: string | null;
    /**
     * The segment's icon encoded as a Data URL. This value is only specified
     * whenever the icon changes. If you explicitly want to query this value,
     * remount the component. The String itself may be empty. This indicates
     * that there is no icon.
     */
    icon_change: string | null;
}
/** The state object describing a comparison to visualize. */
export interface DetailedTimerComponentComparisonStateJson {
    /** The name of the comparison. */
    name: string;
    /** The time to show for the comparison. */
    time: string;
}
/**
 * Represents the current state of the Layout Editor in order to visualize it
 * properly.
 */
export interface LayoutEditorStateJson {
    /** The name of all the components in the layout. */
    components: string[];
    /** Describes which actions are currently available. */
    buttons: LayoutEditorButtonsJson;
    /** The index of the currently selected component. */
    selected_component: number;
    /**
     * A generic description of the settings available for the selected
     * component and their current values.
     */
    component_settings: SettingsDescriptionJson;
    /**
     * A generic description of the general settings available for the layout
     * and their current values.
     */
    general_settings: SettingsDescriptionJson;
}
/**
 * Describes which actions are currently available. Depending on how many
 * components exist and which one is selected, only some actions can be executed
 * successfully.
 */
export interface LayoutEditorButtonsJson {
    /**
     * Describes whether the currently selected component can be removed. If
     * there's only one component in the layout, it can't be removed.
     */
    can_remove: boolean;
    /**
     * Describes whether the currently selected component can be moved up. If
     * the first component is selected, it can't be moved.
     */
    can_move_up: boolean;
    /**
     * Describes whether the currently selected component can be moved down. If
     * the last component is selected, it can't be moved.
     */
    can_move_down: boolean;
}
/** A generic description of the settings available and their current values. */
export interface SettingsDescriptionJson {
    /**
     * All of the different settings that are available and their current
     * values.
     */
    fields: SettingsDescriptionFieldJson[];
}
/** A Field describes a single setting by its name and its current value. */
export interface SettingsDescriptionFieldJson {
    /** The name of the setting. */
    text: string;
    /** The current value of the setting. */
    value: SettingsDescriptionValueJson;
}
/**
 * Describes a setting's value. Such a value can be of a variety of different
 * types.
 */
export declare type SettingsDescriptionValueJson = {
    Bool: boolean;
} | {
    UInt: number;
} | {
    Int: number;
} | {
    String: string;
} | {
    OptionalString: string | null;
} | {
    Float: number;
} | {
    Accuracy: AccuracyJson;
} | {
    DigitsFormat: DigitsFormatJson;
} | {
    OptionalTimingMethod: TimingMethodJson | null;
} | {
    Color: Color;
} | {
    OptionalColor: Color | null;
} | {
    Gradient: Gradient;
} | {
    Alignment: Alignment;
} | {
    CustomCombobox: CustomCombobox;
};
/**
 * A custom Combobox containing its current value and a list of possible
 * values.
 */
export interface CustomCombobox {
    value: string;
    list: string[];
    mandatory: boolean;
}
/**
 * The Accuracy describes how many digits to show for the fractional part of a
 * time.
 */
export declare type AccuracyJson = "Seconds" | "Tenths" | "Hundredths" | "Milliseconds";
/**
 * A Timing Method describes which form of timing is used. This can either be
 * Real Time or Game Time.
 */
export declare type TimingMethodJson = "RealTime" | "GameTime";
/**
 * A Digits Format describes how many digits of a time to always shown. The
 * times are prefixed by zeros to fill up the remaining digits.
 */
export declare type DigitsFormatJson = "SingleDigitSeconds" | "DoubleDigitSeconds" | "SingleDigitMinutes" | "DoubleDigitMinutes" | "SingleDigitHours" | "DoubleDigitHours";
/**
 * Represents the current state of the Run Editor in order to visualize it
 * properly.
 */
export interface RunEditorStateJson {
    /**
     * The game's icon encoded as a Data URL. This value is only specified
     * whenever the icon changes. The String itself may be empty. This
     * indicates that there is no icon.
     */
    icon_change: string | null;
    /** The name of the game the Run is for. */
    game: string;
    /** The name of the category the Run is for. */
    category: string;
    /**
     * The timer offset specifies the time that the timer starts at when starting a
     * new attempt.
     */
    offset: string;
    /**
     * The number of times this Run has been attempted by the runner. This
     * is mostly just a visual number and has no effect on any history.
     */
    attempts: number;
    /**
     * The timing method that is currently selected to be visualized and
     * edited.
     */
    timing_method: TimingMethodJson;
    /** The state of all the segments. */
    segments: RunEditorRowJson[];
    /** The names of all the custom comparisons that exist for this Run. */
    comparison_names: string[];
    /** Describes which actions are currently available. */
    buttons: RunEditorButtonsJson;
    /**
     * Additional metadata of this Run, like the platform and region of the
     * game.
     */
    metadata: RunMetadataJson;
}
/**
 * The Run Metadata stores additional information about a run, like the
 * platform and region of the game. All of this information is optional.
 */
export interface RunMetadataJson {
    /**
     * The speedrun.com Run ID of the run. You need to ensure that the record
     * on speedrun.com matches up with the Personal Best of this run. This may
     * be empty if there's no association.
     */
    run_id: string;
    /**
     * The name of the platform this game is run on. This may be empty if it's
     * not specified.
     */
    platform_name: string;
    /**
     * Specifies whether this speedrun is done on an emulator. Keep in mind
     * that `false` may also mean that this information is simply not known.
     */
    uses_emulator: boolean;
    /**
     * The name of the region this game is from. This may be empty if it's not
     * specified.
     */
    region_name: string;
    /**
     * Stores all the variables. A variable is an arbitrary key value pair
     * storing additional information about the category. An example of this
     * may be whether Amiibos are used in this category.
     */
    variables: {
        [key: string]: string;
    };
}
/**
 * Describes which actions are currently available. Depending on how many
 * segments exist and which ones are selected, only some actions can be
 * executed successfully.
 */
export interface RunEditorButtonsJson {
    /**
     * Describes whether the currently selected segments can be removed. If all
     * segments are selected, they can't be removed.
     */
    can_remove: boolean;
    /**
     * Describes whether the currently selected segments can be moved up. If
     * any one of the selected segments is the first segment, then they can't
     * be moved.
     */
    can_move_up: boolean;
    /**
     * Describes whether the currently selected segments can be moved down. If
     * any one of the selected segments is the last segment, then they can't be
     * moved.
     */
    can_move_down: boolean;
}
/** Describes the current state of a segment. */
export interface RunEditorRowJson {
    /**
     * The segment's icon encoded as a Data URL. This value is only specified
     * whenever the icon changes. The String itself may be empty. This
     * indicates that there is no icon.
     */
    icon_change: string | null;
    /** The name of the segment. */
    name: string;
    /** The segment's split time for the active timing method. */
    split_time: string;
    /** The segment time for the active timing method. */
    segment_time: string;
    /** The best segment time for the active timing method. */
    best_segment_time: string;
    /**
     * All of the times of the custom comparison for the active timing method.
     * The order of these matches up with the order of the custom comparisons
     * provided by the Run Editor's State object.
     */
    comparison_times: string[];
    /** Describes the segment's selection state. */
    selected: "NotSelected" | "Selected" | "Active";
}
/**
 * A Semantic Color describes a color by some meaningful event that is
 * happening. This information can be visualized as a color, but can also be
 * interpreted in other ways by the consumer of this API.
 */
export declare type SemanticColor = "Default" | "AheadGainingTime" | "AheadLosingTime" | "BehindLosingTime" | "BehindGainingTime" | "BestSegment" | "NotRunning" | "Paused" | "PersonalBest";
/**
 * The analysis module provides a variety of functions for calculating
 * information about runs.
 */
export declare class AnalysisRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The analysis module provides a variety of functions for calculating
 * information about runs.
 */
export declare class AnalysisRefMut extends AnalysisRef {
}
/**
 * The analysis module provides a variety of functions for calculating
 * information about runs.
 */
export declare class Analysis extends AnalysisRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: Analysis) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Calculates the Sum of Best Segments for the timing method provided. This is
     * the fastest time possible to complete a run of a category, based on
     * information collected from all the previous attempts. This often matches up
     * with the sum of the best segment times of all the segments, but that may not
     * always be the case, as skipped segments may introduce combined segments that
     * may be faster than the actual sum of their best segment times. The name is
     * therefore a bit misleading, but sticks around for historical reasons. You
     * can choose to do a simple calculation instead, which excludes the Segment
     * History from the calculation process. If there's an active attempt, you can
     * choose to take it into account as well. Can return null.
     */
    static calculateSumOfBest(run: RunRef, simpleCalculation: boolean, useCurrentRun: boolean, method: number): TimeSpan | null;
    /**
     * Calculates the total playtime of the passed Run.
     */
    static calculateTotalPlaytimeForRun(run: RunRef): TimeSpan;
    /**
     * Calculates the total playtime of the passed Timer.
     */
    static calculateTotalPlaytimeForTimer(timer: TimerRef): TimeSpan;
}
/**
 * An Atomic Date Time represents a UTC Date Time that tries to be as close to
 * an atomic clock as possible.
 */
export declare class AtomicDateTimeRef {
    ptr: number;
    /**
     * Represents whether the date time is actually properly derived from an
     * atomic clock. If the synchronization with the atomic clock didn't happen
     * yet or failed, this is set to false.
     */
    isSynchronized(): boolean;
    /**
     * Converts this atomic date time into a RFC 2822 formatted date time.
     */
    toRfc2822(): string;
    /**
     * Converts this atomic date time into a RFC 3339 formatted date time.
     */
    toRfc3339(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * An Atomic Date Time represents a UTC Date Time that tries to be as close to
 * an atomic clock as possible.
 */
export declare class AtomicDateTimeRefMut extends AtomicDateTimeRef {
}
/**
 * An Atomic Date Time represents a UTC Date Time that tries to be as close to
 * an atomic clock as possible.
 */
export declare class AtomicDateTime extends AtomicDateTimeRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: AtomicDateTime) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * An Attempt describes information about an attempt to run a specific category
 * by a specific runner in the past. Every time a new attempt is started and
 * then reset, an Attempt describing general information about it is created.
 */
export declare class AttemptRef {
    ptr: number;
    /**
     * Accesses the unique index of the attempt. This index is unique for the
     * Run, not for all of them.
     */
    index(): number;
    /**
     * Accesses the split time of the last segment. If the attempt got reset
     * early and didn't finish, this may be empty.
     */
    time(): TimeRef;
    /**
     * Accesses the amount of time the attempt has been paused for. If it is not
     * known, this returns null. This means that it may not necessarily be
     * possible to differentiate whether a Run has not been paused or it simply
     * wasn't stored.
     */
    pauseTime(): TimeSpanRef | null;
    /**
     * Accesses the point in time the attempt was started at. This returns null
     * if this information is not known.
     */
    started(): AtomicDateTime | null;
    /**
     * Accesses the point in time the attempt was ended at. This returns null if
     * this information is not known.
     */
    ended(): AtomicDateTime | null;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * An Attempt describes information about an attempt to run a specific category
 * by a specific runner in the past. Every time a new attempt is started and
 * then reset, an Attempt describing general information about it is created.
 */
export declare class AttemptRefMut extends AttemptRef {
}
/**
 * An Attempt describes information about an attempt to run a specific category
 * by a specific runner in the past. Every time a new attempt is started and
 * then reset, an Attempt describing general information about it is created.
 */
export declare class Attempt extends AttemptRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: Attempt) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Blank Space Component is simply an empty component that doesn't show
 * anything other than a background. It mostly serves as padding between other
 * components.
 */
export declare class BlankSpaceComponentRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Blank Space Component is simply an empty component that doesn't show
 * anything other than a background. It mostly serves as padding between other
 * components.
 */
export declare class BlankSpaceComponentRefMut extends BlankSpaceComponentRef {
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef): any;
    /**
     * Calculates the component's state based on the timer provided.
     */
    state(timer: TimerRef): BlankSpaceComponentState;
}
/**
 * The Blank Space Component is simply an empty component that doesn't show
 * anything other than a background. It mostly serves as padding between other
 * components.
 */
export declare class BlankSpaceComponent extends BlankSpaceComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: BlankSpaceComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Blank Space Component.
     */
    static new(): BlankSpaceComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class BlankSpaceComponentStateRef {
    ptr: number;
    /**
     * The height of the component.
     */
    height(): number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class BlankSpaceComponentStateRefMut extends BlankSpaceComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class BlankSpaceComponentState extends BlankSpaceComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: BlankSpaceComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * A Component provides information about a run in a way that is easy to
 * visualize. This type can store any of the components provided by this crate.
 */
export declare class ComponentRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A Component provides information about a run in a way that is easy to
 * visualize. This type can store any of the components provided by this crate.
 */
export declare class ComponentRefMut extends ComponentRef {
}
/**
 * A Component provides information about a run in a way that is easy to
 * visualize. This type can store any of the components provided by this crate.
 */
export declare class Component extends ComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: Component) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Current Comparison Component is a component that shows the name of the
 * comparison that is currently selected to be compared against.
 */
export declare class CurrentComparisonComponentRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Current Comparison Component is a component that shows the name of the
 * comparison that is currently selected to be compared against.
 */
export declare class CurrentComparisonComponentRefMut extends CurrentComparisonComponentRef {
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef): any;
    /**
     * Calculates the component's state based on the timer provided.
     */
    state(timer: TimerRef): CurrentComparisonComponentState;
}
/**
 * The Current Comparison Component is a component that shows the name of the
 * comparison that is currently selected to be compared against.
 */
export declare class CurrentComparisonComponent extends CurrentComparisonComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: CurrentComparisonComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Current Comparison Component.
     */
    static new(): CurrentComparisonComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class CurrentComparisonComponentStateRef {
    ptr: number;
    /**
     * The label's text.
     */
    text(): string;
    /**
     * The name of the comparison that is currently selected to be compared
     * against.
     */
    comparison(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class CurrentComparisonComponentStateRefMut extends CurrentComparisonComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class CurrentComparisonComponentState extends CurrentComparisonComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: CurrentComparisonComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Current Pace Component is a component that shows a prediction of the
 * current attempt's final time, if the current attempt's pace matches the
 * chosen comparison for the remainder of the run.
 */
export declare class CurrentPaceComponentRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Current Pace Component is a component that shows a prediction of the
 * current attempt's final time, if the current attempt's pace matches the
 * chosen comparison for the remainder of the run.
 */
export declare class CurrentPaceComponentRefMut extends CurrentPaceComponentRef {
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef): any;
    /**
     * Calculates the component's state based on the timer provided.
     */
    state(timer: TimerRef): CurrentPaceComponentState;
}
/**
 * The Current Pace Component is a component that shows a prediction of the
 * current attempt's final time, if the current attempt's pace matches the
 * chosen comparison for the remainder of the run.
 */
export declare class CurrentPaceComponent extends CurrentPaceComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: CurrentPaceComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Current Pace Component.
     */
    static new(): CurrentPaceComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class CurrentPaceComponentStateRef {
    ptr: number;
    /**
     * The label's text.
     */
    text(): string;
    /**
     * The current pace.
     */
    time(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class CurrentPaceComponentStateRefMut extends CurrentPaceComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class CurrentPaceComponentState extends CurrentPaceComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: CurrentPaceComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Delta Component is a component that shows the how far ahead or behind
 * the current attempt is compared to the chosen comparison.
 */
export declare class DeltaComponentRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Delta Component is a component that shows the how far ahead or behind
 * the current attempt is compared to the chosen comparison.
 */
export declare class DeltaComponentRefMut extends DeltaComponentRef {
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): any;
    /**
     * Calculates the component's state based on the timer and the layout
     * settings provided.
     */
    state(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): DeltaComponentState;
}
/**
 * The Delta Component is a component that shows the how far ahead or behind
 * the current attempt is compared to the chosen comparison.
 */
export declare class DeltaComponent extends DeltaComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: DeltaComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Delta Component.
     */
    static new(): DeltaComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class DeltaComponentStateRef {
    ptr: number;
    /**
     * The label's text.
     */
    text(): string;
    /**
     * The delta.
     */
    time(): string;
    /**
     * The semantic coloring information the delta time carries.
     */
    semanticColor(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class DeltaComponentStateRefMut extends DeltaComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class DeltaComponentState extends DeltaComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: DeltaComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Detailed Timer Component is a component that shows two timers, one for
 * the total time of the current attempt and one showing the time of just the
 * current segment. Other information, like segment times of up to two
 * comparisons, the segment icon, and the segment's name, can also be shown.
 */
export declare class DetailedTimerComponentRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Detailed Timer Component is a component that shows two timers, one for
 * the total time of the current attempt and one showing the time of just the
 * current segment. Other information, like segment times of up to two
 * comparisons, the segment icon, and the segment's name, can also be shown.
 */
export declare class DetailedTimerComponentRefMut extends DetailedTimerComponentRef {
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): any;
    /**
     * Calculates the component's state based on the timer and layout settings
     * provided.
     */
    state(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): DetailedTimerComponentState;
}
/**
 * The Detailed Timer Component is a component that shows two timers, one for
 * the total time of the current attempt and one showing the time of just the
 * current segment. Other information, like segment times of up to two
 * comparisons, the segment icon, and the segment's name, can also be shown.
 */
export declare class DetailedTimerComponent extends DetailedTimerComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: DetailedTimerComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Detailed Timer Component.
     */
    static new(): DetailedTimerComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class DetailedTimerComponentStateRef {
    ptr: number;
    /**
     * The time shown by the component's main timer without the fractional part.
     */
    timerTime(): string;
    /**
     * The fractional part of the time shown by the main timer (including the dot).
     */
    timerFraction(): string;
    /**
     * The semantic coloring information the main timer's time carries.
     */
    timerSemanticColor(): string;
    /**
     * The time shown by the component's segment timer without the fractional part.
     */
    segmentTimerTime(): string;
    /**
     * The fractional part of the time shown by the segment timer (including the
     * dot).
     */
    segmentTimerFraction(): string;
    /**
     * Returns whether the first comparison is visible.
     */
    comparison1Visible(): boolean;
    /**
     * Returns the name of the first comparison. You may not call this if the first
     * comparison is not visible.
     */
    comparison1Name(): string;
    /**
     * Returns the time of the first comparison. You may not call this if the first
     * comparison is not visible.
     */
    comparison1Time(): string;
    /**
     * Returns whether the second comparison is visible.
     */
    comparison2Visible(): boolean;
    /**
     * Returns the name of the second comparison. You may not call this if the
     * second comparison is not visible.
     */
    comparison2Name(): string;
    /**
     * Returns the time of the second comparison. You may not call this if the
     * second comparison is not visible.
     */
    comparison2Time(): string;
    /**
     * The segment's icon encoded as a Data URL. This value is only specified
     * whenever the icon changes. If you explicitly want to query this value,
     * remount the component. The String itself may be empty. This indicates
     * that there is no icon.
     */
    iconChange(): string | null;
    /**
     * The name of the segment. This may be null if it's not supposed to be
     * visualized.
     */
    segmentName(): string | null;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class DetailedTimerComponentStateRefMut extends DetailedTimerComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class DetailedTimerComponentState extends DetailedTimerComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: DetailedTimerComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * With a Fuzzy List, you can implement a fuzzy searching algorithm. The list
 * stores all the items that can be searched for. With the `search` method you
 * can then execute the actual fuzzy search which returns a list of all the
 * elements found. This can be used to implement searching in a list of games.
 */
export declare class FuzzyListRef {
    ptr: number;
    /**
     * Searches for the pattern provided in the list. A list of all the
     * matching elements is returned. The returned list has a maximum amount of
     * elements provided to this method.
     */
    search(pattern: string, max: number): any;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * With a Fuzzy List, you can implement a fuzzy searching algorithm. The list
 * stores all the items that can be searched for. With the `search` method you
 * can then execute the actual fuzzy search which returns a list of all the
 * elements found. This can be used to implement searching in a list of games.
 */
export declare class FuzzyListRefMut extends FuzzyListRef {
    /**
     * Adds a new element to the list.
     */
    push(text: string): void;
}
/**
 * With a Fuzzy List, you can implement a fuzzy searching algorithm. The list
 * stores all the items that can be searched for. With the `search` method you
 * can then execute the actual fuzzy search which returns a list of all the
 * elements found. This can be used to implement searching in a list of games.
 */
export declare class FuzzyList extends FuzzyListRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: FuzzyList) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Fuzzy List.
     */
    static new(): FuzzyList;
}
/**
 * The general settings of the layout that apply to all components.
 */
export declare class GeneralLayoutSettingsRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The general settings of the layout that apply to all components.
 */
export declare class GeneralLayoutSettingsRefMut extends GeneralLayoutSettingsRef {
}
/**
 * The general settings of the layout that apply to all components.
 */
export declare class GeneralLayoutSettings extends GeneralLayoutSettingsRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: GeneralLayoutSettings) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a default general layout settings configuration.
     */
    static default(): GeneralLayoutSettings;
}
/**
 * The Graph Component visualizes how far the current attempt has been ahead or
 * behind the chosen comparison throughout the whole attempt. All the
 * individual deltas are shown as points in a graph.
 */
export declare class GraphComponentRef {
    ptr: number;
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): any;
    /**
     * Calculates the component's state based on the timer and layout settings
     * provided.
     */
    state(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): GraphComponentState;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Graph Component visualizes how far the current attempt has been ahead or
 * behind the chosen comparison throughout the whole attempt. All the
 * individual deltas are shown as points in a graph.
 */
export declare class GraphComponentRefMut extends GraphComponentRef {
}
/**
 * The Graph Component visualizes how far the current attempt has been ahead or
 * behind the chosen comparison throughout the whole attempt. All the
 * individual deltas are shown as points in a graph.
 */
export declare class GraphComponent extends GraphComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: GraphComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Graph Component.
     */
    static new(): GraphComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 * All the coordinates are in the range 0..1.
 */
export declare class GraphComponentStateRef {
    ptr: number;
    /**
     * Returns the amount of points to visualize. Connect all of them to visualize
     * the graph. If the live delta is active, the last point is to be interpreted
     * as a preview of the next split that is about to happen. Use the partial fill
     * color to visualize the region beneath that graph segment.
     */
    pointsLen(): number;
    /**
     * Returns the x coordinate of the point specified. You may not provide an out
     * of bounds index.
     */
    pointX(index: number): number;
    /**
     * Returns the y coordinate of the point specified. You may not provide an out
     * of bounds index.
     */
    pointY(index: number): number;
    /**
     * Describes whether the segment the point specified is visualizing achieved a
     * new best segment time. Use the best segment color for it, in that case. You
     * may not provide an out of bounds index.
     */
    pointIsBestSegment(index: number): boolean;
    /**
     * Describes how many horizontal grid lines to visualize.
     */
    horizontalGridLinesLen(): number;
    /**
     * Accesses the y coordinate of the horizontal grid line specified. You may not
     * provide an out of bounds index.
     */
    horizontalGridLine(index: number): number;
    /**
     * Describes how many vertical grid lines to visualize.
     */
    verticalGridLinesLen(): number;
    /**
     * Accesses the x coordinate of the vertical grid line specified. You may not
     * provide an out of bounds index.
     */
    verticalGridLine(index: number): number;
    /**
     * The y coordinate that separates the region that shows the times that are
     * ahead of the comparison and those that are behind.
     */
    middle(): number;
    /**
     * If the live delta is active, the last point is to be interpreted as a
     * preview of the next split that is about to happen. Use the partial fill
     * color to visualize the region beneath that graph segment.
     */
    isLiveDeltaActive(): boolean;
    /**
     * Describes whether the graph is flipped vertically. For visualizing the
     * graph, this usually doesn't need to be interpreted, as this information is
     * entirely encoded into the other variables.
     */
    isFlipped(): boolean;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 * All the coordinates are in the range 0..1.
 */
export declare class GraphComponentStateRefMut extends GraphComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 * All the coordinates are in the range 0..1.
 */
export declare class GraphComponentState extends GraphComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: GraphComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * With a Hotkey System the runner can use hotkeys on their keyboard to control
 * the Timer. The hotkeys are global, so the application doesn't need to be in
 * focus. The behavior of the hotkeys depends on the platform and is stubbed
 * out on platforms that don't support hotkeys. You can turn off a Hotkey
 * System temporarily. By default the Hotkey System is activated.
 */
export declare class HotkeySystemRef {
    ptr: number;
    /**
     * Deactivates the Hotkey System. No hotkeys will go through until it gets
     * activated again. If it's already deactivated, nothing happens.
     */
    deactivate(): void;
    /**
     * Activates a previously deactivated Hotkey System. If it's already
     * active, nothing happens.
     */
    activate(): void;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * With a Hotkey System the runner can use hotkeys on their keyboard to control
 * the Timer. The hotkeys are global, so the application doesn't need to be in
 * focus. The behavior of the hotkeys depends on the platform and is stubbed
 * out on platforms that don't support hotkeys. You can turn off a Hotkey
 * System temporarily. By default the Hotkey System is activated.
 */
export declare class HotkeySystemRefMut extends HotkeySystemRef {
}
/**
 * With a Hotkey System the runner can use hotkeys on their keyboard to control
 * the Timer. The hotkeys are global, so the application doesn't need to be in
 * focus. The behavior of the hotkeys depends on the platform and is stubbed
 * out on platforms that don't support hotkeys. You can turn off a Hotkey
 * System temporarily. By default the Hotkey System is activated.
 */
export declare class HotkeySystem extends HotkeySystemRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: HotkeySystem) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Hotkey System for a Timer with the default hotkeys.
     */
    static new(sharedTimer: SharedTimer): HotkeySystem | null;
}
/**
 * A Layout allows you to combine multiple components together to visualize a
 * variety of information the runner is interested in.
 */
export declare class LayoutRef {
    ptr: number;
    /**
     * Clones the layout.
     */
    clone(): Layout;
    /**
     * Encodes the settings of the layout as JSON.
     */
    settingsAsJson(): any;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A Layout allows you to combine multiple components together to visualize a
 * variety of information the runner is interested in.
 */
export declare class LayoutRefMut extends LayoutRef {
    /**
     * Calculates the layout's state based on the timer provided and encodes it as
     * JSON. You can use this to visualize all of the components of a layout.
     */
    stateAsJson(timer: TimerRef): any;
    /**
     * Adds a new component to the end of the layout.
     */
    push(component: Component): void;
    /**
     * Scrolls up all the components in the layout that can be scrolled up.
     */
    scrollUp(): void;
    /**
     * Scrolls down all the components in the layout that can be scrolled down.
     */
    scrollDown(): void;
    /**
     * Remounts all the components as if they were freshly initialized. Some
     * components may only provide some information whenever it changes or when
     * their state is first queried. Remounting returns this information again,
     * whenever the layout's state is queried the next time.
     */
    remount(): void;
}
/**
 * A Layout allows you to combine multiple components together to visualize a
 * variety of information the runner is interested in.
 */
export declare class Layout extends LayoutRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: Layout) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new empty layout with no components.
     */
    static new(): Layout;
    /**
     * Creates a new default layout that contains a default set of components
     * in order to provide a good default layout for runners. Which components
     * are provided by this and how they are configured may change in the
     * future.
     */
    static defaultLayout(): Layout;
    /**
     * Parses a layout from the given JSON description of its settings. null is
     * returned if it couldn't be parsed.
     */
    static parseJson(settings: any): Layout | null;
}
/**
 * The Layout Editor allows modifying Layouts while ensuring all the different
 * invariants of the Layout objects are upheld no matter what kind of
 * operations are being applied. It provides the current state of the editor as
 * state objects that can be visualized by any kind of User Interface.
 */
export declare class LayoutEditorRef {
    ptr: number;
    /**
     * Encodes the Layout Editor's state as JSON in order to visualize it.
     */
    stateAsJson(): any;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Layout Editor allows modifying Layouts while ensuring all the different
 * invariants of the Layout objects are upheld no matter what kind of
 * operations are being applied. It provides the current state of the editor as
 * state objects that can be visualized by any kind of User Interface.
 */
export declare class LayoutEditorRefMut extends LayoutEditorRef {
    /**
     * Encodes the layout's state as JSON based on the timer provided. You can use
     * this to visualize all of the components of a layout, while it is still being
     * edited by the Layout Editor.
     */
    layoutStateAsJson(timer: TimerRef): any;
    /**
     * Selects the component with the given index in order to modify its
     * settings. Only a single component is selected at any given time. You may
     * not provide an invalid index.
     */
    select(index: number): void;
    /**
     * Adds the component provided to the end of the layout. The newly added
     * component becomes the selected component.
     */
    addComponent(component: Component): void;
    /**
     * Removes the currently selected component, unless there's only one
     * component in the layout. The next component becomes the selected
     * component. If there's none, the previous component becomes the selected
     * component instead.
     */
    removeComponent(): void;
    /**
     * Moves the selected component up, unless the first component is selected.
     */
    moveComponentUp(): void;
    /**
     * Moves the selected component down, unless the last component is
     * selected.
     */
    moveComponentDown(): void;
    /**
     * Moves the selected component to the index provided. You may not provide
     * an invalid index.
     */
    moveComponent(dstIndex: number): void;
    /**
     * Duplicates the currently selected component. The copy gets placed right
     * after the selected component and becomes the newly selected component.
     */
    duplicateComponent(): void;
    /**
     * Sets a setting's value of the selected component by its setting index
     * to the given value.
     *
     * This panics if the type of the value to be set is not compatible with
     * the type of the setting's value. A panic can also occur if the index of
     * the setting provided is out of bounds.
     */
    setComponentSettingsValue(index: number, value: SettingValue): void;
    /**
     * Sets a setting's value of the general settings by its setting index to
     * the given value.
     *
     * This panics if the type of the value to be set is not compatible with
     * the type of the setting's value. A panic can also occur if the index of
     * the setting provided is out of bounds.
     */
    setGeneralSettingsValue(index: number, value: SettingValue): void;
}
/**
 * The Layout Editor allows modifying Layouts while ensuring all the different
 * invariants of the Layout objects are upheld no matter what kind of
 * operations are being applied. It provides the current state of the editor as
 * state objects that can be visualized by any kind of User Interface.
 */
export declare class LayoutEditor extends LayoutEditorRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: LayoutEditor) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Layout Editor that modifies the Layout provided. Creation of
     * the Layout Editor fails when a Layout with no components is provided. In
     * that case null is returned instead.
     */
    static new(layout: Layout): LayoutEditor | null;
    /**
     * Closes the Layout Editor and gives back access to the modified Layout. In
     * case you want to implement a Cancel Button, just dispose the Layout object
     * you get here.
     */
    close(): Layout;
}
/**
 * A run parsed by the Composite Parser. This contains the Run itself and
 * information about which parser parsed it.
 */
export declare class ParseRunResultRef {
    ptr: number;
    /**
     * Returns true if the Run got parsed successfully. false is returned otherwise.
     */
    parsedSuccessfully(): boolean;
    /**
     * Accesses the name of the Parser that parsed the Run. You may not call this
     * if the Run wasn't parsed successfully.
     */
    timerKind(): string;
    /**
     * Checks whether the Parser parsed a generic timer. Since a generic timer can
     * have any name, it may clash with the specific timer formats that
     * livesplit-core supports. With this function you can determine if a generic
     * timer format was parsed, instead of one of the more specific timer formats.
     */
    isGenericTimer(): boolean;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A run parsed by the Composite Parser. This contains the Run itself and
 * information about which parser parsed it.
 */
export declare class ParseRunResultRefMut extends ParseRunResultRef {
}
/**
 * A run parsed by the Composite Parser. This contains the Run itself and
 * information about which parser parsed it.
 */
export declare class ParseRunResult extends ParseRunResultRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: ParseRunResult) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Moves the actual Run object out of the Result. You may not call this if the
     * Run wasn't parsed successfully.
     */
    unwrap(): Run;
}
/**
 * The Possible Time Save Component is a component that shows how much time the
 * chosen comparison could've saved for the current segment, based on the Best
 * Segments. This component also allows showing the Total Possible Time Save
 * for the remainder of the current attempt.
 */
export declare class PossibleTimeSaveComponentRef {
    ptr: number;
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef): any;
    /**
     * Calculates the component's state based on the timer provided.
     */
    state(timer: TimerRef): PossibleTimeSaveComponentState;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Possible Time Save Component is a component that shows how much time the
 * chosen comparison could've saved for the current segment, based on the Best
 * Segments. This component also allows showing the Total Possible Time Save
 * for the remainder of the current attempt.
 */
export declare class PossibleTimeSaveComponentRefMut extends PossibleTimeSaveComponentRef {
}
/**
 * The Possible Time Save Component is a component that shows how much time the
 * chosen comparison could've saved for the current segment, based on the Best
 * Segments. This component also allows showing the Total Possible Time Save
 * for the remainder of the current attempt.
 */
export declare class PossibleTimeSaveComponent extends PossibleTimeSaveComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: PossibleTimeSaveComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Possible Time Save Component.
     */
    static new(): PossibleTimeSaveComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class PossibleTimeSaveComponentStateRef {
    ptr: number;
    /**
     * The label's text.
     */
    text(): string;
    /**
     * The current possible time save.
     */
    time(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class PossibleTimeSaveComponentStateRefMut extends PossibleTimeSaveComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class PossibleTimeSaveComponentState extends PossibleTimeSaveComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: PossibleTimeSaveComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * Describes a potential clean up that could be applied. You can query a
 * message describing the details of this potential clean up. A potential clean
 * up can then be turned into an actual clean up in order to apply it to the
 * Run.
 */
export declare class PotentialCleanUpRef {
    ptr: number;
    /**
     * Accesses the message describing the potential clean up that can be applied
     * to a Run.
     */
    message(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * Describes a potential clean up that could be applied. You can query a
 * message describing the details of this potential clean up. A potential clean
 * up can then be turned into an actual clean up in order to apply it to the
 * Run.
 */
export declare class PotentialCleanUpRefMut extends PotentialCleanUpRef {
}
/**
 * Describes a potential clean up that could be applied. You can query a
 * message describing the details of this potential clean up. A potential clean
 * up can then be turned into an actual clean up in order to apply it to the
 * Run.
 */
export declare class PotentialCleanUp extends PotentialCleanUpRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: PotentialCleanUp) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Previous Segment Component is a component that shows how much time was
 * saved or lost during the previous segment based on the chosen comparison.
 * Additionally, the potential time save for the previous segment can be
 * displayed. This component switches to a `Live Segment` view that shows
 * active time loss whenever the runner is losing time on the current segment.
 */
export declare class PreviousSegmentComponentRef {
    ptr: number;
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): any;
    /**
     * Calculates the component's state based on the timer and the layout
     * settings provided.
     */
    state(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): PreviousSegmentComponentState;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Previous Segment Component is a component that shows how much time was
 * saved or lost during the previous segment based on the chosen comparison.
 * Additionally, the potential time save for the previous segment can be
 * displayed. This component switches to a `Live Segment` view that shows
 * active time loss whenever the runner is losing time on the current segment.
 */
export declare class PreviousSegmentComponentRefMut extends PreviousSegmentComponentRef {
}
/**
 * The Previous Segment Component is a component that shows how much time was
 * saved or lost during the previous segment based on the chosen comparison.
 * Additionally, the potential time save for the previous segment can be
 * displayed. This component switches to a `Live Segment` view that shows
 * active time loss whenever the runner is losing time on the current segment.
 */
export declare class PreviousSegmentComponent extends PreviousSegmentComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: PreviousSegmentComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Previous Segment Component.
     */
    static new(): PreviousSegmentComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class PreviousSegmentComponentStateRef {
    ptr: number;
    /**
     * The label's text.
     */
    text(): string;
    /**
     * The delta (and possibly the possible time save).
     */
    time(): string;
    /**
     * The semantic coloring information the delta time carries.
     */
    semanticColor(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class PreviousSegmentComponentStateRefMut extends PreviousSegmentComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class PreviousSegmentComponentState extends PreviousSegmentComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: PreviousSegmentComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * A Run stores the split times for a specific game and category of a runner.
 */
export declare class RunRef {
    ptr: number;
    /**
     * Clones the Run object.
     */
    clone(): Run;
    /**
     * Accesses the name of the game this Run is for.
     */
    gameName(): string;
    /**
     * Accesses the Data URL storing the game icon's data. If there is no game
     * icon, this returns an empty string instead of a URL.
     */
    gameIcon(): string;
    /**
     * Accesses the name of the category this Run is for.
     */
    categoryName(): string;
    /**
     * Returns a file name (without the extension) suitable for this Run that
     * is built the following way:
     *
     * Game Name - Category Name
     *
     * If either is empty, the dash is omitted. Special characters that cause
     * problems in file names are also omitted. If an extended category name is
     * used, the variables of the category are appended in a parenthesis.
     */
    extendedFileName(useExtendedCategoryName: boolean): string;
    /**
     * Returns a name suitable for this Run that is built the following way:
     *
     * Game Name - Category Name
     *
     * If either is empty, the dash is omitted. If an extended category name is
     * used, the variables of the category are appended in a parenthesis.
     */
    extendedName(useExtendedCategoryName: boolean): string;
    /**
     * Returns an extended category name that possibly includes the region,
     * platform and variables, depending on the arguments provided. An extended
     * category name may look like this:
     *
     * Any% (No Tuner, JPN, Wii Emulator)
     */
    extendedCategoryName(showRegion: boolean, showPlatform: boolean, showVariables: boolean): string;
    /**
     * Returns the amount of runs that have been attempted with these splits.
     */
    attemptCount(): number;
    /**
     * Accesses additional metadata of this Run, like the platform and region
     * of the game.
     */
    metadata(): RunMetadataRef;
    /**
     * Accesses the time an attempt of this Run should start at.
     */
    offset(): TimeSpanRef;
    /**
     * Returns the amount of segments stored in this Run.
     */
    len(): number;
    /**
     * Returns whether the Run has been modified and should be saved so that the
     * changes don't get lost.
     */
    hasBeenModified(): boolean;
    /**
     * Accesses a certain segment of this Run. You may not provide an out of bounds
     * index.
     */
    segment(index: number): SegmentRef;
    /**
     * Returns the amount attempt history elements are stored in this Run.
     */
    attemptHistoryLen(): number;
    /**
     * Accesses the an attempt history element by its index. This does not store
     * the actual segment times, just the overall attempt information. Information
     * about the individual segments is stored within each segment. You may not
     * provide an out of bounds index.
     */
    attemptHistoryIndex(index: number): AttemptRef;
    /**
     * Saves a Run as a LiveSplit splits file (*.lss). If the run is actively in
     * use by a timer, use the appropriate method on the timer instead, in order to
     * properly save the current attempt as well.
     */
    saveAsLss(): string;
    /**
     * Returns the amount of custom comparisons stored in this Run.
     */
    customComparisonsLen(): number;
    /**
     * Accesses a custom comparison stored in this Run by its index. This includes
     * `Personal Best` but excludes all the other Comparison Generators. You may
     * not provide an out of bounds index.
     */
    customComparison(index: number): string;
    /**
     * Accesses the Auto Splitter Settings that are encoded as XML.
     */
    autoSplitterSettings(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A Run stores the split times for a specific game and category of a runner.
 */
export declare class RunRefMut extends RunRef {
    /**
     * Pushes the segment provided to the end of the list of segments of this Run.
     */
    pushSegment(segment: Segment): void;
    /**
     * Sets the name of the game this Run is for.
     */
    setGameName(game: string): void;
    /**
     * Sets the name of the category this Run is for.
     */
    setCategoryName(category: string): void;
    /**
     * Marks the Run as modified, so that it is known that there are changes
     * that should be saved.
     */
    markAsModified(): void;
}
/**
 * A Run stores the split times for a specific game and category of a runner.
 */
export declare class Run extends RunRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: Run) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Run object with no segments.
     */
    static new(): Run;
    /**
     * Attempts to parse a splits file from an array by invoking the corresponding
     * parser for the file format detected. A path to the splits file can be
     * provided, which helps saving the splits file again later. Additionally you
     * need to specify if additional files, like external images are allowed to be
     * loaded. If you are using livesplit-core in a server-like environment, set
     * this to false. Only client-side applications should set this to true.
     */
    static parse(data: number, length: number, path: string, loadFiles: boolean): ParseRunResult;
    /**
     * Attempts to parse a splits file from a file by invoking the corresponding
     * parser for the file format detected. A path to the splits file can be
     * provided, which helps saving the splits file again later. Additionally you
     * need to specify if additional files, like external images are allowed to be
     * loaded. If you are using livesplit-core in a server-like environment, set
     * this to false. Only client-side applications should set this to true. On
     * Unix you pass a file descriptor to this function. On Windows you pass a file
     * handle to this function. The file descriptor / handle does not get closed.
     */
    static parseFileHandle(handle: number, path: string, loadFiles: boolean): ParseRunResult;
    static parseArray(data: Int8Array, path: string, loadFiles: boolean): ParseRunResult;
    static parseString(text: string, path: string, loadFiles: boolean): ParseRunResult;
}
/**
 * The Run Editor allows modifying Runs while ensuring that all the different
 * invariants of the Run objects are upheld no matter what kind of operations
 * are being applied to the Run. It provides the current state of the editor as
 * state objects that can be visualized by any kind of User Interface.
 */
export declare class RunEditorRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Run Editor allows modifying Runs while ensuring that all the different
 * invariants of the Run objects are upheld no matter what kind of operations
 * are being applied to the Run. It provides the current state of the editor as
 * state objects that can be visualized by any kind of User Interface.
 */
export declare class RunEditorRefMut extends RunEditorRef {
    /**
     * Calculates the Run Editor's state and encodes it as
     * JSON in order to visualize it.
     */
    stateAsJson(): any;
    /**
     * Selects a different timing method for being modified.
     */
    selectTimingMethod(method: number): void;
    /**
     * Unselects the segment with the given index. If it's not selected or the
     * index is out of bounds, nothing happens. The segment is not unselected,
     * when it is the only segment that is selected. If the active segment is
     * unselected, the most recently selected segment remaining becomes the
     * active segment.
     */
    unselect(index: number): void;
    /**
     * In addition to the segments that are already selected, the segment with
     * the given index is being selected. The segment chosen also becomes the
     * active segment.
     *
     * This panics if the index of the segment provided is out of bounds.
     */
    selectAdditionally(index: number): void;
    /**
     * Selects the segment with the given index. All other segments are
     * unselected. The segment chosen also becomes the active segment.
     *
     * This panics if the index of the segment provided is out of bounds.
     */
    selectOnly(index: number): void;
    /**
     * Sets the name of the game.
     */
    setGameName(game: string): void;
    /**
     * Sets the name of the category.
     */
    setCategoryName(category: string): void;
    /**
     * Parses and sets the timer offset from the string provided. The timer
     * offset specifies the time, the timer starts at when starting a new
     * attempt.
     */
    parseAndSetOffset(offset: string): boolean;
    /**
     * Parses and sets the attempt count from the string provided. Changing
     * this has no affect on the attempt history or the segment history. This
     * number is mostly just a visual number for the runner.
     */
    parseAndSetAttemptCount(attempts: string): boolean;
    /**
     * Sets the game's icon.
     */
    setGameIcon(data: number, length: number): void;
    /**
     * Removes the game's icon.
     */
    removeGameIcon(): void;
    /**
     * Sets the speedrun.com Run ID of the run. You need to ensure that the
     * record on speedrun.com matches up with the Personal Best of this run.
     * This may be empty if there's no association.
     */
    setRunId(name: string): void;
    /**
     * Sets the name of the region this game is from. This may be empty if it's
     * not specified.
     */
    setRegionName(name: string): void;
    /**
     * Sets the name of the platform this game is run on. This may be empty if
     * it's not specified.
     */
    setPlatformName(name: string): void;
    /**
     * Specifies whether this speedrun is done on an emulator. Keep in mind
     * that false may also mean that this information is simply not known.
     */
    setEmulatorUsage(usesEmulator: boolean): void;
    /**
     * Sets the variable with the name specified to the value specified. A
     * variable is an arbitrary key value pair storing additional information
     * about the category. An example of this may be whether Amiibos are used
     * in this category. If the variable doesn't exist yet, it is being
     * inserted.
     */
    setVariable(name: string, value: string): void;
    /**
     * Removes the variable with the name specified.
     */
    removeVariable(name: string): void;
    /**
     * Resets all the Metadata Information.
     */
    clearMetadata(): void;
    /**
     * Inserts a new empty segment above the active segment and adjusts the
     * Run's history information accordingly. The newly created segment is then
     * the only selected segment and also the active segment.
     */
    insertSegmentAbove(): void;
    /**
     * Inserts a new empty segment below the active segment and adjusts the
     * Run's history information accordingly. The newly created segment is then
     * the only selected segment and also the active segment.
     */
    insertSegmentBelow(): void;
    /**
     * Removes all the selected segments, unless all of them are selected. The
     * run's information is automatically adjusted properly. The next
     * not-to-be-removed segment after the active segment becomes the new
     * active segment. If there's none, then the next not-to-be-removed segment
     * before the active segment, becomes the new active segment.
     */
    removeSegments(): void;
    /**
     * Moves all the selected segments up, unless the first segment is
     * selected. The run's information is automatically adjusted properly. The
     * active segment stays the active segment.
     */
    moveSegmentsUp(): void;
    /**
     * Moves all the selected segments down, unless the last segment is
     * selected. The run's information is automatically adjusted properly. The
     * active segment stays the active segment.
     */
    moveSegmentsDown(): void;
    /**
     * Sets the icon of the active segment.
     */
    activeSetIcon(data: number, length: number): void;
    /**
     * Removes the icon of the active segment.
     */
    activeRemoveIcon(): void;
    /**
     * Sets the name of the active segment.
     */
    activeSetName(name: string): void;
    /**
     * Parses a split time from a string and sets it for the active segment with
     * the chosen timing method.
     */
    activeParseAndSetSplitTime(time: string): boolean;
    /**
     * Parses a segment time from a string and sets it for the active segment with
     * the chosen timing method.
     */
    activeParseAndSetSegmentTime(time: string): boolean;
    /**
     * Parses a best segment time from a string and sets it for the active segment
     * with the chosen timing method.
     */
    activeParseAndSetBestSegmentTime(time: string): boolean;
    /**
     * Parses a comparison time for the provided comparison and sets it for the
     * active active segment with the chosen timing method.
     */
    activeParseAndSetComparisonTime(comparison: string, time: string): boolean;
    /**
     * Adds a new custom comparison. It can't be added if it starts with
     * `[Race]` or already exists.
     */
    addComparison(comparison: string): boolean;
    /**
     * Imports the Personal Best from the provided run as a comparison. The
     * comparison can't be added if its name starts with `[Race]` or it already
     * exists.
     */
    importComparison(run: RunRef, comparison: string): boolean;
    /**
     * Removes the chosen custom comparison. You can't remove a Comparison
     * Generator's Comparison or the Personal Best.
     */
    removeComparison(comparison: string): void;
    /**
     * Renames a comparison. The comparison can't be renamed if the new name of
     * the comparison starts with `[Race]` or it already exists.
     */
    renameComparison(oldName: string, newName: string): boolean;
    /**
     * Reorders the custom comparisons by moving the comparison with the source
     * index specified to the destination index specified. Returns false if one
     * of the indices is invalid. The indices are based on the comparison names of
     * the Run Editor's state.
     */
    moveComparison(srcIndex: number, dstIndex: number): boolean;
    /**
     * Clears out the Attempt History and the Segment Histories of all the
     * segments.
     */
    clearHistory(): void;
    /**
     * Clears out the Attempt History, the Segment Histories, all the times,
     * sets the Attempt Count to 0 and clears the speedrun.com run id
     * association. All Custom Comparisons other than `Personal Best` are
     * deleted as well.
     */
    clearTimes(): void;
    /**
     * Creates a Sum of Best Cleaner which allows you to interactively remove
     * potential issues in the segment history that lead to an inaccurate Sum
     * of Best. If you skip a split, whenever you will do the next split, the
     * combined segment time might be faster than the sum of the individual
     * best segments. The Sum of Best Cleaner will point out all of these and
     * allows you to delete them individually if any of them seem wrong.
     */
    cleanSumOfBest(): SumOfBestCleaner;
    setGameIconFromArray(data: Int8Array): void;
    activeSetIconFromArray(data: Int8Array): void;
}
/**
 * The Run Editor allows modifying Runs while ensuring that all the different
 * invariants of the Run objects are upheld no matter what kind of operations
 * are being applied to the Run. It provides the current state of the editor as
 * state objects that can be visualized by any kind of User Interface.
 */
export declare class RunEditor extends RunEditorRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: RunEditor) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Run Editor that modifies the Run provided. Creation of the Run
     * Editor fails when a Run with no segments is provided. If a Run object with
     * no segments is provided, the Run Editor creation fails and null is
     * returned.
     */
    static new(run: Run): RunEditor | null;
    /**
     * Closes the Run Editor and gives back access to the modified Run object. In
     * case you want to implement a Cancel Button, just dispose the Run object you
     * get here.
     */
    close(): Run;
}
/**
 * The Run Metadata stores additional information about a run, like the
 * platform and region of the game. All of this information is optional.
 */
export declare class RunMetadataRef {
    ptr: number;
    /**
     * Accesses the speedrun.com Run ID of the run. This Run ID specify which
     * Record on speedrun.com this run is associated with. This should be
     * changed once the Personal Best doesn't match up with that record
     * anymore. This may be empty if there's no association.
     */
    runId(): string;
    /**
     * Accesses the name of the platform this game is run on. This may be empty
     * if it's not specified.
     */
    platformName(): string;
    /**
     * Returns true if this speedrun is done on an emulator. However false
     * may also indicate that this information is simply not known.
     */
    usesEmulator(): boolean;
    /**
     * Accesses the name of the region this game is from. This may be empty if
     * it's not specified.
     */
    regionName(): string;
    /**
     * Returns an iterator iterating over all the variables and their values
     * that have been specified.
     */
    variables(): RunMetadataVariablesIter;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Run Metadata stores additional information about a run, like the
 * platform and region of the game. All of this information is optional.
 */
export declare class RunMetadataRefMut extends RunMetadataRef {
}
/**
 * The Run Metadata stores additional information about a run, like the
 * platform and region of the game. All of this information is optional.
 */
export declare class RunMetadata extends RunMetadataRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: RunMetadata) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * A Run Metadata variable is an arbitrary key value pair storing additional
 * information about the category. An example of this may be whether Amiibos
 * are used in the category.
 */
export declare class RunMetadataVariableRef {
    ptr: number;
    /**
     * Accesses the name of this Run Metadata variable.
     */
    name(): string;
    /**
     * Accesses the value of this Run Metadata variable.
     */
    value(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A Run Metadata variable is an arbitrary key value pair storing additional
 * information about the category. An example of this may be whether Amiibos
 * are used in the category.
 */
export declare class RunMetadataVariableRefMut extends RunMetadataVariableRef {
}
/**
 * A Run Metadata variable is an arbitrary key value pair storing additional
 * information about the category. An example of this may be whether Amiibos
 * are used in the category.
 */
export declare class RunMetadataVariable extends RunMetadataVariableRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: RunMetadataVariable) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * An iterator iterating over all the Run Metadata variables and their values
 * that have been specified.
 */
export declare class RunMetadataVariablesIterRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * An iterator iterating over all the Run Metadata variables and their values
 * that have been specified.
 */
export declare class RunMetadataVariablesIterRefMut extends RunMetadataVariablesIterRef {
    /**
     * Accesses the next Run Metadata variable. Returns null if there are no more
     * variables.
     */
    next(): RunMetadataVariableRef | null;
}
/**
 * An iterator iterating over all the Run Metadata variables and their values
 * that have been specified.
 */
export declare class RunMetadataVariablesIter extends RunMetadataVariablesIterRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: RunMetadataVariablesIter) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * A Segment describes a point in a speedrun that is suitable for storing a
 * split time. This stores the name of that segment, an icon, the split times
 * of different comparisons, and a history of segment times.
 */
export declare class SegmentRef {
    ptr: number;
    /**
     * Accesses the name of the segment.
     */
    name(): string;
    /**
     * Accesses the icon of the segment encoded as a Data URL storing the image's
     * data. If the image's data is empty, this returns an empty string instead of
     * a URL.
     */
    icon(): string;
    /**
     * Accesses the specified comparison's time. If there's none for this
     * comparison, an empty time is being returned (but not stored in the
     * segment).
     */
    comparison(comparison: string): TimeRef;
    /**
     * Accesses the split time of the Personal Best for this segment. If it
     * doesn't exist, an empty time is returned.
     */
    personalBestSplitTime(): TimeRef;
    /**
     * Accesses the Best Segment Time.
     */
    bestSegmentTime(): TimeRef;
    /**
     * Accesses the Segment History of this segment.
     */
    segmentHistory(): SegmentHistoryRef;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A Segment describes a point in a speedrun that is suitable for storing a
 * split time. This stores the name of that segment, an icon, the split times
 * of different comparisons, and a history of segment times.
 */
export declare class SegmentRefMut extends SegmentRef {
}
/**
 * A Segment describes a point in a speedrun that is suitable for storing a
 * split time. This stores the name of that segment, an icon, the split times
 * of different comparisons, and a history of segment times.
 */
export declare class Segment extends SegmentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: Segment) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Segment with the name given.
     */
    static new(name: string): Segment;
}
/**
 * Stores the segment times achieved for a certain segment. Each segment is
 * tagged with an index. Only segment times with an index larger than 0 are
 * considered times actually achieved by the runner, while the others are
 * artifacts of route changes and similar algorithmic changes.
 */
export declare class SegmentHistoryRef {
    ptr: number;
    /**
     * Iterates over all the segment times and their indices.
     */
    iter(): SegmentHistoryIter;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * Stores the segment times achieved for a certain segment. Each segment is
 * tagged with an index. Only segment times with an index larger than 0 are
 * considered times actually achieved by the runner, while the others are
 * artifacts of route changes and similar algorithmic changes.
 */
export declare class SegmentHistoryRefMut extends SegmentHistoryRef {
}
/**
 * Stores the segment times achieved for a certain segment. Each segment is
 * tagged with an index. Only segment times with an index larger than 0 are
 * considered times actually achieved by the runner, while the others are
 * artifacts of route changes and similar algorithmic changes.
 */
export declare class SegmentHistory extends SegmentHistoryRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: SegmentHistory) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * A segment time achieved for a segment. It is tagged with an index. Only
 * segment times with an index larger than 0 are considered times actually
 * achieved by the runner, while the others are artifacts of route changes and
 * similar algorithmic changes.
 */
export declare class SegmentHistoryElementRef {
    ptr: number;
    /**
     * Accesses the index of the segment history element.
     */
    index(): number;
    /**
     * Accesses the segment time of the segment history element.
     */
    time(): TimeRef;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A segment time achieved for a segment. It is tagged with an index. Only
 * segment times with an index larger than 0 are considered times actually
 * achieved by the runner, while the others are artifacts of route changes and
 * similar algorithmic changes.
 */
export declare class SegmentHistoryElementRefMut extends SegmentHistoryElementRef {
}
/**
 * A segment time achieved for a segment. It is tagged with an index. Only
 * segment times with an index larger than 0 are considered times actually
 * achieved by the runner, while the others are artifacts of route changes and
 * similar algorithmic changes.
 */
export declare class SegmentHistoryElement extends SegmentHistoryElementRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: SegmentHistoryElement) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * Iterates over all the segment times of a segment and their indices.
 */
export declare class SegmentHistoryIterRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * Iterates over all the segment times of a segment and their indices.
 */
export declare class SegmentHistoryIterRefMut extends SegmentHistoryIterRef {
    /**
     * Accesses the next Segment History element. Returns null if there are no
     * more elements.
     */
    next(): SegmentHistoryElementRef | null;
}
/**
 * Iterates over all the segment times of a segment and their indices.
 */
export declare class SegmentHistoryIter extends SegmentHistoryIterRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: SegmentHistoryIter) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Separator Component is a simple component that only serves to render
 * separators between components.
 */
export declare class SeparatorComponentRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Separator Component is a simple component that only serves to render
 * separators between components.
 */
export declare class SeparatorComponentRefMut extends SeparatorComponentRef {
}
/**
 * The Separator Component is a simple component that only serves to render
 * separators between components.
 */
export declare class SeparatorComponent extends SeparatorComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: SeparatorComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Separator Component.
     */
    static new(): SeparatorComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * Describes a setting's value. Such a value can be of a variety of different
 * types.
 */
export declare class SettingValueRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * Describes a setting's value. Such a value can be of a variety of different
 * types.
 */
export declare class SettingValueRefMut extends SettingValueRef {
}
/**
 * Describes a setting's value. Such a value can be of a variety of different
 * types.
 */
export declare class SettingValue extends SettingValueRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: SettingValue) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new setting value from a boolean value.
     */
    static fromBool(value: boolean): SettingValue;
    /**
     * Creates a new setting value from an unsigned integer.
     */
    static fromUint(value: number): SettingValue;
    /**
     * Creates a new setting value from a signed integer.
     */
    static fromInt(value: number): SettingValue;
    /**
     * Creates a new setting value from a string.
     */
    static fromString(value: string): SettingValue;
    /**
     * Creates a new setting value from a string that has the type `optional string`.
     */
    static fromOptionalString(value: string): SettingValue;
    /**
     * Creates a new empty setting value that has the type `optional string`.
     */
    static fromOptionalEmptyString(): SettingValue;
    /**
     * Creates a new setting value from a floating point number.
     */
    static fromFloat(value: number): SettingValue;
    /**
     * Creates a new setting value from an accuracy name. If it doesn't match a
     * known accuracy, null is returned.
     */
    static fromAccuracy(value: string): SettingValue | null;
    /**
     * Creates a new setting value from a digits format name. If it doesn't match a
     * known digits format, null is returned.
     */
    static fromDigitsFormat(value: string): SettingValue | null;
    /**
     * Creates a new setting value from a timing method name with the type
     * `optional timing method`. If it doesn't match a known timing method, null
     * is returned.
     */
    static fromOptionalTimingMethod(value: string): SettingValue | null;
    /**
     * Creates a new empty setting value with the type `optional timing method`.
     */
    static fromOptionalEmptyTimingMethod(): SettingValue;
    /**
     * Creates a new setting value from the color provided as RGBA.
     */
    static fromColor(r: number, g: number, b: number, a: number): SettingValue;
    /**
     * Creates a new setting value from the color provided as RGBA with the type
     * `optional color`.
     */
    static fromOptionalColor(r: number, g: number, b: number, a: number): SettingValue;
    /**
     * Creates a new empty setting value with the type `optional color`.
     */
    static fromOptionalEmptyColor(): SettingValue;
    /**
     * Creates a new setting value that is a transparent gradient.
     */
    static fromTransparentGradient(): SettingValue;
    /**
     * Creates a new setting value from the vertical gradient provided as two RGBA colors.
     */
    static fromVerticalGradient(r1: number, g1: number, b1: number, a1: number, r2: number, g2: number, b2: number, a2: number): SettingValue;
    /**
     * Creates a new setting value from the horizontal gradient provided as two RGBA colors.
     */
    static fromHorizontalGradient(r1: number, g1: number, b1: number, a1: number, r2: number, g2: number, b2: number, a2: number): SettingValue;
    /**
     * Creates a new setting value from the alignment name provided. If it doesn't
     * match a known alignment, null is returned.
     */
    static fromAlignment(value: string): SettingValue | null;
}
/**
 * A Shared Timer that can be used to share a single timer object with multiple
 * owners.
 */
export declare class SharedTimerRef {
    ptr: number;
    /**
     * Creates a new shared timer handle that shares the same timer. The inner
     * timer object only gets disposed when the final handle gets disposed.
     */
    share(): SharedTimer;
    /**
     * Requests read access to the timer that is being shared. This blocks the
     * thread as long as there is an active write lock. Dispose the read lock when
     * you are done using the timer.
     */
    read(): TimerReadLock;
    /**
     * Requests write access to the timer that is being shared. This blocks the
     * thread as long as there are active write or read locks. Dispose the write
     * lock when you are done using the timer.
     */
    write(): TimerWriteLock;
    /**
     * Replaces the timer that is being shared by the timer provided. This blocks
     * the thread as long as there are active write or read locks. Everyone who is
     * sharing the old timer will share the provided timer after successful
     * completion.
     */
    replaceInner(timer: Timer): void;
    readWith<T>(action: (timer: TimerRef) => T): T;
    writeWith<T>(action: (timer: TimerRefMut) => T): T;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A Shared Timer that can be used to share a single timer object with multiple
 * owners.
 */
export declare class SharedTimerRefMut extends SharedTimerRef {
}
/**
 * A Shared Timer that can be used to share a single timer object with multiple
 * owners.
 */
export declare class SharedTimer extends SharedTimerRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: SharedTimer) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Splits Component is the main component for visualizing all the split
 * times. Each segment is shown in a tabular fashion showing the segment icon,
 * segment name, the delta compared to the chosen comparison, and the split
 * time. The list provides scrolling functionality, so not every segment needs
 * to be shown all the time.
 */
export declare class SplitsComponentRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Splits Component is the main component for visualizing all the split
 * times. Each segment is shown in a tabular fashion showing the segment icon,
 * segment name, the delta compared to the chosen comparison, and the split
 * time. The list provides scrolling functionality, so not every segment needs
 * to be shown all the time.
 */
export declare class SplitsComponentRefMut extends SplitsComponentRef {
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): any;
    /**
     * Calculates the component's state based on the timer and layout settings
     * provided.
     */
    state(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): SplitsComponentState;
    /**
     * Scrolls up the window of the segments that are shown. Doesn't move the
     * scroll window if it reaches the top of the segments.
     */
    scrollUp(): void;
    /**
     * Scrolls down the window of the segments that are shown. Doesn't move the
     * scroll window if it reaches the bottom of the segments.
     */
    scrollDown(): void;
    /**
     * The amount of segments to show in the list at any given time. If this is
     * set to 0, all the segments are shown. If this is set to a number lower
     * than the total amount of segments, only a certain window of all the
     * segments is shown. This window can scroll up or down.
     */
    setVisualSplitCount(count: number): void;
    /**
     * If there's more segments than segments that are shown, the window
     * showing the segments automatically scrolls up and down when the current
     * segment changes. This count determines the minimum number of future
     * segments to be shown in this scrolling window when it automatically
     * scrolls.
     */
    setSplitPreviewCount(count: number): void;
    /**
     * If not every segment is shown in the scrolling window of segments, then
     * this determines whether the final segment is always to be shown, as it
     * contains valuable information about the total duration of the chosen
     * comparison, which is often the runner's Personal Best.
     */
    setAlwaysShowLastSplit(alwaysShowLastSplit: boolean): void;
    /**
     * If the last segment is to always be shown, this determines whether to
     * show a more pronounced separator in front of the last segment, if it is
     * not directly adjacent to the segment shown right before it in the
     * scrolling window.
     */
    setSeparatorLastSplit(separatorLastSplit: boolean): void;
}
/**
 * The Splits Component is the main component for visualizing all the split
 * times. Each segment is shown in a tabular fashion showing the segment icon,
 * segment name, the delta compared to the chosen comparison, and the split
 * time. The list provides scrolling functionality, so not every segment needs
 * to be shown all the time.
 */
export declare class SplitsComponent extends SplitsComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: SplitsComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Splits Component.
     */
    static new(): SplitsComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object that describes a single segment's information to visualize.
 */
export declare class SplitsComponentStateRef {
    ptr: number;
    /**
     * Describes whether a more pronounced separator should be shown in front of
     * the last segment provided.
     */
    finalSeparatorShown(): boolean;
    /**
     * Returns the amount of segments to visualize.
     */
    len(): number;
    /**
     * Returns the amount of icon changes that happened in this state object.
     */
    iconChangeCount(): number;
    /**
     * Accesses the index of the segment of the icon change with the specified
     * index. This is based on the index in the run, not on the index of the
     * SplitState in the State object. The corresponding index is the index field
     * of the SplitState object. You may not provide an out of bounds index.
     */
    iconChangeSegmentIndex(iconChangeIndex: number): number;
    /**
     * The segment's icon encoded as a Data URL of the icon change with the
     * specified index. The String itself may be empty. This indicates that there
     * is no icon. You may not provide an out of bounds index.
     */
    iconChangeIcon(iconChangeIndex: number): string;
    /**
     * The name of the segment with the specified index. You may not provide an out
     * of bounds index.
     */
    name(index: number): string;
    /**
     * The delta to show for the segment with the specified index. You may not
     * provide an out of bounds index.
     */
    delta(index: number): string;
    /**
     * The split time to show for the segment with the specified index. You may not
     * provide an out of bounds index.
     */
    time(index: number): string;
    /**
     * The semantic coloring information the delta time carries of the segment with
     * the specified index. You may not provide an out of bounds index.
     */
    semanticColor(index: number): string;
    /**
     * Describes if the segment with the specified index is the segment the active
     * attempt is currently on.
     */
    isCurrentSplit(index: number): boolean;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object that describes a single segment's information to visualize.
 */
export declare class SplitsComponentStateRefMut extends SplitsComponentStateRef {
}
/**
 * The state object that describes a single segment's information to visualize.
 */
export declare class SplitsComponentState extends SplitsComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: SplitsComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * A Sum of Best Cleaner allows you to interactively remove potential issues in
 * the Segment History that lead to an inaccurate Sum of Best. If you skip a
 * split, whenever you get to the next split, the combined segment time might
 * be faster than the sum of the individual best segments. The Sum of Best
 * Cleaner will point out all of occurrences of this and allows you to delete
 * them individually if any of them seem wrong.
 */
export declare class SumOfBestCleanerRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A Sum of Best Cleaner allows you to interactively remove potential issues in
 * the Segment History that lead to an inaccurate Sum of Best. If you skip a
 * split, whenever you get to the next split, the combined segment time might
 * be faster than the sum of the individual best segments. The Sum of Best
 * Cleaner will point out all of occurrences of this and allows you to delete
 * them individually if any of them seem wrong.
 */
export declare class SumOfBestCleanerRefMut extends SumOfBestCleanerRef {
    /**
     * Returns the next potential clean up. If there are no more potential
     * clean ups, null is returned.
     */
    nextPotentialCleanUp(): PotentialCleanUp | null;
    /**
     * Applies a clean up to the Run.
     */
    apply(cleanUp: PotentialCleanUp): void;
}
/**
 * A Sum of Best Cleaner allows you to interactively remove potential issues in
 * the Segment History that lead to an inaccurate Sum of Best. If you skip a
 * split, whenever you get to the next split, the combined segment time might
 * be faster than the sum of the individual best segments. The Sum of Best
 * Cleaner will point out all of occurrences of this and allows you to delete
 * them individually if any of them seem wrong.
 */
export declare class SumOfBestCleaner extends SumOfBestCleanerRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: SumOfBestCleaner) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Sum of Best Segments Component shows the fastest possible time to
 * complete a run of this category, based on information collected from all the
 * previous attempts. This often matches up with the sum of the best segment
 * times of all the segments, but that may not always be the case, as skipped
 * segments may introduce combined segments that may be faster than the actual
 * sum of their best segment times. The name is therefore a bit misleading, but
 * sticks around for historical reasons.
 */
export declare class SumOfBestComponentRef {
    ptr: number;
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef): any;
    /**
     * Calculates the component's state based on the timer provided.
     */
    state(timer: TimerRef): SumOfBestComponentState;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Sum of Best Segments Component shows the fastest possible time to
 * complete a run of this category, based on information collected from all the
 * previous attempts. This often matches up with the sum of the best segment
 * times of all the segments, but that may not always be the case, as skipped
 * segments may introduce combined segments that may be faster than the actual
 * sum of their best segment times. The name is therefore a bit misleading, but
 * sticks around for historical reasons.
 */
export declare class SumOfBestComponentRefMut extends SumOfBestComponentRef {
}
/**
 * The Sum of Best Segments Component shows the fastest possible time to
 * complete a run of this category, based on information collected from all the
 * previous attempts. This often matches up with the sum of the best segment
 * times of all the segments, but that may not always be the case, as skipped
 * segments may introduce combined segments that may be faster than the actual
 * sum of their best segment times. The name is therefore a bit misleading, but
 * sticks around for historical reasons.
 */
export declare class SumOfBestComponent extends SumOfBestComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: SumOfBestComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Sum of Best Segments Component.
     */
    static new(): SumOfBestComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class SumOfBestComponentStateRef {
    ptr: number;
    /**
     * The label's text.
     */
    text(): string;
    /**
     * The sum of best segments.
     */
    time(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class SumOfBestComponentStateRefMut extends SumOfBestComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class SumOfBestComponentState extends SumOfBestComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: SumOfBestComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Text Component simply visualizes any given text. This can either be a
 * single centered text, or split up into a left and right text, which is
 * suitable for a situation where you have a label and a value.
 */
export declare class TextComponentRef {
    ptr: number;
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(): any;
    /**
     * Calculates the component's state.
     */
    state(): TextComponentState;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Text Component simply visualizes any given text. This can either be a
 * single centered text, or split up into a left and right text, which is
 * suitable for a situation where you have a label and a value.
 */
export declare class TextComponentRefMut extends TextComponentRef {
    /**
     * Sets the centered text. If the current mode is split, it is switched to
     * centered mode.
     */
    setCenter(text: string): void;
    /**
     * Sets the left text. If the current mode is centered, it is switched to
     * split mode, with the right text being empty.
     */
    setLeft(text: string): void;
    /**
     * Sets the right text. If the current mode is centered, it is switched to
     * split mode, with the left text being empty.
     */
    setRight(text: string): void;
}
/**
 * The Text Component simply visualizes any given text. This can either be a
 * single centered text, or split up into a left and right text, which is
 * suitable for a situation where you have a label and a value.
 */
export declare class TextComponent extends TextComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: TextComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Text Component.
     */
    static new(): TextComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TextComponentStateRef {
    ptr: number;
    /**
     * Accesses the left part of the text. If the text isn't split up, an empty
     * string is returned instead.
     */
    left(): string;
    /**
     * Accesses the right part of the text. If the text isn't split up, an empty
     * string is returned instead.
     */
    right(): string;
    /**
     * Accesses the centered text. If the text isn't centered, an empty string is
     * returned instead.
     */
    center(): string;
    /**
     * Returns whether the text is split up into a left and right part.
     */
    isSplit(): boolean;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TextComponentStateRefMut extends TextComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TextComponentState extends TextComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: TextComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * A time that can store a Real Time and a Game Time. Both of them are
 * optional.
 */
export declare class TimeRef {
    ptr: number;
    /**
     * Clones the time.
     */
    clone(): Time;
    /**
     * The Real Time value. This may be null if this time has no Real Time value.
     */
    realTime(): TimeSpanRef | null;
    /**
     * The Game Time value. This may be null if this time has no Game Time value.
     */
    gameTime(): TimeSpanRef | null;
    /**
     * Access the time's value for the timing method specified.
     */
    index(timingMethod: number): TimeSpanRef | null;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A time that can store a Real Time and a Game Time. Both of them are
 * optional.
 */
export declare class TimeRefMut extends TimeRef {
}
/**
 * A time that can store a Real Time and a Game Time. Both of them are
 * optional.
 */
export declare class Time extends TimeRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: Time) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * A Time Span represents a certain span of time.
 */
export declare class TimeSpanRef {
    ptr: number;
    /**
     * Clones the Time Span.
     */
    clone(): TimeSpan;
    /**
     * Returns the total amount of seconds (including decimals) this Time Span
     * represents.
     */
    totalSeconds(): number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A Time Span represents a certain span of time.
 */
export declare class TimeSpanRefMut extends TimeSpanRef {
}
/**
 * A Time Span represents a certain span of time.
 */
export declare class TimeSpan extends TimeSpanRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: TimeSpan) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Time Span from a given amount of seconds.
     */
    static fromSeconds(seconds: number): TimeSpan;
    /**
     * Parses a Time Span from a string. Returns null if the time can't be
     * parsed.
     */
    static parse(text: string): TimeSpan | null;
}
/**
 * A Timer provides all the capabilities necessary for doing speedrun attempts.
 */
export declare class TimerRef {
    ptr: number;
    /**
     * Returns the currently selected Timing Method.
     */
    currentTimingMethod(): number;
    /**
     * Returns the current comparison that is being compared against. This may
     * be a custom comparison or one of the Comparison Generators.
     */
    currentComparison(): string;
    /**
     * Returns whether Game Time is currently initialized. Game Time
     * automatically gets uninitialized for each new attempt.
     */
    isGameTimeInitialized(): boolean;
    /**
     * Returns whether the Game Timer is currently paused. If the Game Timer is
     * not paused, it automatically increments similar to Real Time.
     */
    isGameTimePaused(): boolean;
    /**
     * Accesses the loading times. Loading times are defined as Game Time - Real Time.
     */
    loadingTimes(): TimeSpanRef;
    /**
     * Returns the current Timer Phase.
     */
    currentPhase(): number;
    /**
     * Accesses the Run in use by the Timer.
     */
    getRun(): RunRef;
    /**
     * Saves the Run in use by the Timer as a LiveSplit splits file (*.lss).
     */
    saveAsLss(): string;
    /**
     * Prints out debug information representing the whole state of the Timer. This
     * is being written to stdout.
     */
    printDebug(): void;
    /**
     * Returns the current time of the Timer. The Game Time is null if the Game
     * Time has not been initialized.
     */
    currentTime(): TimeRef;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A Timer provides all the capabilities necessary for doing speedrun attempts.
 */
export declare class TimerRefMut extends TimerRef {
    /**
     * Replaces the Run object used by the Timer with the Run object provided. If
     * the Run provided contains no segments, it can't be used for timing and is
     * not being modified. Otherwise the Run that was in use by the Timer gets
     * stored in the Run object provided. Before the Run is returned, the current
     * attempt is reset and the splits are being updated depending on the
     * `update_splits` parameter. The return value indicates whether the Run got
     * replaced successfully.
     */
    replaceRun(run: RunRefMut, updateSplits: boolean): boolean;
    /**
     * Sets the Run object used by the Timer with the Run object provided. If the
     * Run provided contains no segments, it can't be used for timing and gets
     * returned again. If the Run object can be set, the original Run object in use
     * by the Timer is disposed by this method and null is returned.
     */
    setRun(run: Run): Run | null;
    /**
     * Starts the Timer if there is no attempt in progress. If that's not the
     * case, nothing happens.
     */
    start(): void;
    /**
     * If an attempt is in progress, stores the current time as the time of the
     * current split. The attempt ends if the last split time is stored.
     */
    split(): void;
    /**
     * Starts a new attempt or stores the current time as the time of the
     * current split. The attempt ends if the last split time is stored.
     */
    splitOrStart(): void;
    /**
     * Skips the current split if an attempt is in progress and the
     * current split is not the last split.
     */
    skipSplit(): void;
    /**
     * Removes the split time from the last split if an attempt is in progress
     * and there is a previous split. The Timer Phase also switches to
     * `Running` if it previously was `Ended`.
     */
    undoSplit(): void;
    /**
     * Resets the current attempt if there is one in progress. If the splits
     * are to be updated, all the information of the current attempt is stored
     * in the Run's history. Otherwise the current attempt's information is
     * discarded.
     */
    reset(updateSplits: boolean): void;
    /**
     * Resets the current attempt if there is one in progress. The splits are
     * updated such that the current attempt's split times are being stored as
     * the new Personal Best.
     */
    resetAndSetAttemptAsPb(): void;
    /**
     * Pauses an active attempt that is not paused.
     */
    pause(): void;
    /**
     * Resumes an attempt that is paused.
     */
    resume(): void;
    /**
     * Toggles an active attempt between `Paused` and `Running`.
     */
    togglePause(): void;
    /**
     * Toggles an active attempt between `Paused` and `Running` or starts an
     * attempt if there's none in progress.
     */
    togglePauseOrStart(): void;
    /**
     * Removes all the pause times from the current time. If the current
     * attempt is paused, it also resumes that attempt. Additionally, if the
     * attempt is finished, the final split time is adjusted to not include the
     * pause times as well.
     *
     * # Warning
     *
     * This behavior is not entirely optimal, as generally only the final split
     * time is modified, while all other split times are left unmodified, which
     * may not be what actually happened during the run.
     */
    undoAllPauses(): void;
    /**
     * Sets the current Timing Method to the Timing Method provided.
     */
    setCurrentTimingMethod(method: number): void;
    /**
     * Switches the current comparison to the next comparison in the list.
     */
    switchToNextComparison(): void;
    /**
     * Switches the current comparison to the previous comparison in the list.
     */
    switchToPreviousComparison(): void;
    /**
     * Initializes Game Time for the current attempt. Game Time automatically
     * gets uninitialized for each new attempt.
     */
    initializeGameTime(): void;
    /**
     * Deinitializes Game Time for the current attempt.
     */
    deinitializeGameTime(): void;
    /**
     * Pauses the Game Timer such that it doesn't automatically increment
     * similar to Real Time.
     */
    pauseGameTime(): void;
    /**
     * Resumes the Game Timer such that it automatically increments similar to
     * Real Time, starting from the Game Time it was paused at.
     */
    resumeGameTime(): void;
    /**
     * Sets the Game Time to the time specified. This also works if the Game
     * Time is paused, which can be used as a way of updating the Game Timer
     * periodically without it automatically moving forward. This ensures that
     * the Game Timer never shows any time that is not coming from the game.
     */
    setGameTime(time: TimeSpanRef): void;
    /**
     * Instead of setting the Game Time directly, this method can be used to
     * just specify the amount of time the game has been loading. The Game Time
     * is then automatically determined by Real Time - Loading Times.
     */
    setLoadingTimes(time: TimeSpanRef): void;
    /**
     * Marks the Run as unmodified, so that it is known that all the changes
     * have been saved.
     */
    markAsUnmodified(): void;
}
/**
 * A Timer provides all the capabilities necessary for doing speedrun attempts.
 */
export declare class Timer extends TimerRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: Timer) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Timer based on a Run object storing all the information
     * about the splits. The Run object needs to have at least one segment, so
     * that the Timer can store the final time. If a Run object with no
     * segments is provided, the Timer creation fails and null is returned.
     */
    static new(run: Run): Timer | null;
    /**
     * Consumes the Timer and creates a Shared Timer that can be shared across
     * multiple threads with multiple owners.
     */
    intoShared(): SharedTimer;
    /**
     * Takes out the Run from the Timer and resets the current attempt if there
     * is one in progress. If the splits are to be updated, all the information
     * of the current attempt is stored in the Run's history. Otherwise the
     * current attempt's information is discarded.
     */
    intoRun(updateSplits: boolean): Run;
}
/**
 * The Timer Component is a component that shows the total time of the current
 * attempt as a digital clock. The color of the time shown is based on a how
 * well the current attempt is doing compared to the chosen comparison.
 */
export declare class TimerComponentRef {
    ptr: number;
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): any;
    /**
     * Calculates the component's state based on the timer and the layout
     * settings provided.
     */
    state(timer: TimerRef, layoutSettings: GeneralLayoutSettingsRef): TimerComponentState;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Timer Component is a component that shows the total time of the current
 * attempt as a digital clock. The color of the time shown is based on a how
 * well the current attempt is doing compared to the chosen comparison.
 */
export declare class TimerComponentRefMut extends TimerComponentRef {
}
/**
 * The Timer Component is a component that shows the total time of the current
 * attempt as a digital clock. The color of the time shown is based on a how
 * well the current attempt is doing compared to the chosen comparison.
 */
export declare class TimerComponent extends TimerComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: TimerComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Timer Component.
     */
    static new(): TimerComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TimerComponentStateRef {
    ptr: number;
    /**
     * The time shown by the component without the fractional part.
     */
    time(): string;
    /**
     * The fractional part of the time shown (including the dot).
     */
    fraction(): string;
    /**
     * The semantic coloring information the time carries.
     */
    semanticColor(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TimerComponentStateRefMut extends TimerComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TimerComponentState extends TimerComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: TimerComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * A Timer Read Lock allows temporary read access to a timer. Dispose this to
 * release the read lock.
 */
export declare class TimerReadLockRef {
    ptr: number;
    /**
     * Accesses the timer.
     */
    timer(): TimerRef;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A Timer Read Lock allows temporary read access to a timer. Dispose this to
 * release the read lock.
 */
export declare class TimerReadLockRefMut extends TimerReadLockRef {
}
/**
 * A Timer Read Lock allows temporary read access to a timer. Dispose this to
 * release the read lock.
 */
export declare class TimerReadLock extends TimerReadLockRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: TimerReadLock) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * A Timer Write Lock allows temporary write access to a timer. Dispose this to
 * release the write lock.
 */
export declare class TimerWriteLockRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * A Timer Write Lock allows temporary write access to a timer. Dispose this to
 * release the write lock.
 */
export declare class TimerWriteLockRefMut extends TimerWriteLockRef {
    /**
     * Accesses the timer.
     */
    timer(): TimerRefMut;
}
/**
 * A Timer Write Lock allows temporary write access to a timer. Dispose this to
 * release the write lock.
 */
export declare class TimerWriteLock extends TimerWriteLockRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: TimerWriteLock) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Title Component is a component that shows the name of the game and the
 * category that is being run. Additionally, the game icon, the attempt count,
 * and the total number of successfully finished runs can be shown.
 */
export declare class TitleComponentRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Title Component is a component that shows the name of the game and the
 * category that is being run. Additionally, the game icon, the attempt count,
 * and the total number of successfully finished runs can be shown.
 */
export declare class TitleComponentRefMut extends TitleComponentRef {
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef): any;
    /**
     * Calculates the component's state based on the timer provided.
     */
    state(timer: TimerRef): TitleComponentState;
}
/**
 * The Title Component is a component that shows the name of the game and the
 * category that is being run. Additionally, the game icon, the attempt count,
 * and the total number of successfully finished runs can be shown.
 */
export declare class TitleComponent extends TitleComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: TitleComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Title Component.
     */
    static new(): TitleComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TitleComponentStateRef {
    ptr: number;
    /**
     * The game's icon encoded as a Data URL. This value is only specified whenever
     * the icon changes. If you explicitly want to query this value, remount the
     * component. The String itself may be empty. This indicates that there is no
     * icon. If no change occurred, null is returned instead.
     */
    iconChange(): string | null;
    /**
     * The first title line to show. This is either the game's name, or a
     * combination of the game's name and the category.
     */
    line1(): string;
    /**
     * By default the category name is shown on the second line. Based on the
     * settings, it can however instead be shown in a single line together with
     * the game name. In that case null is returned instead.
     */
    line2(): string | null;
    /**
     * Specifies whether the title should centered or aligned to the left
     * instead.
     */
    isCentered(): boolean;
    /**
     * Returns whether the amount of successfully finished attempts is supposed to
     * be shown.
     */
    showsFinishedRuns(): boolean;
    /**
     * Returns the amount of successfully finished attempts.
     */
    finishedRuns(): number;
    /**
     * Returns whether the amount of total attempts is supposed to be shown.
     */
    showsAttempts(): boolean;
    /**
     * Returns the amount of total attempts.
     */
    attempts(): number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TitleComponentStateRefMut extends TitleComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TitleComponentState extends TitleComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: TitleComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}
/**
 * The Total Playtime Component is a component that shows the total amount of
 * time that the current category has been played for.
 */
export declare class TotalPlaytimeComponentRef {
    ptr: number;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The Total Playtime Component is a component that shows the total amount of
 * time that the current category has been played for.
 */
export declare class TotalPlaytimeComponentRefMut extends TotalPlaytimeComponentRef {
    /**
     * Encodes the component's state information as JSON.
     */
    stateAsJson(timer: TimerRef): any;
    /**
     * Calculates the component's state based on the timer provided.
     */
    state(timer: TimerRef): TotalPlaytimeComponentState;
}
/**
 * The Total Playtime Component is a component that shows the total amount of
 * time that the current category has been played for.
 */
export declare class TotalPlaytimeComponent extends TotalPlaytimeComponentRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: TotalPlaytimeComponent) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
    /**
     * Creates a new Total Playtime Component.
     */
    static new(): TotalPlaytimeComponent;
    /**
     * Converts the component into a generic component suitable for using with a
     * layout.
     */
    intoGeneric(): Component;
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TotalPlaytimeComponentStateRef {
    ptr: number;
    /**
     * The label's text.
     */
    text(): string;
    /**
     * The total playtime.
     */
    time(): string;
    /**
     * This constructor is an implementation detail. Do not use this.
     */
    constructor(ptr: number);
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TotalPlaytimeComponentStateRefMut extends TotalPlaytimeComponentStateRef {
}
/**
 * The state object describes the information to visualize for this component.
 */
export declare class TotalPlaytimeComponentState extends TotalPlaytimeComponentStateRefMut {
    /**
     * Allows for scoped usage of the object. The object is guaranteed to get
     * disposed once this function returns. You are free to dispose the object
     * early yourself anywhere within the scope. The scope's return value gets
     * carried to the outside of this function.
     */
    with<T>(closure: (obj: TotalPlaytimeComponentState) => T): T;
    /**
     * Disposes the object, allowing it to clean up all of its memory. You need
     * to call this for every object that you don't use anymore and hasn't
     * already been disposed.
     */
    dispose(): void;
}