/// <reference types="react" />
import React from "react";
import { Dispatch, Reducer, ReducerAction, ReducerState, RefObject } from "react";
import { Map, OrderedSet, OrderedMap } from "immutable";
import { List as ImmutableList } from "immutable";
import { ReactReduxContextValue } from "react-redux";
import { Store, AnyAction, Action } from "redux";
import { UseTranslationResponse as UseI18nTranslationResponse } from "react-i18next";
import { EventBus } from "ts-bus";
import { ThunkAction } from "redux-thunk";
/* eslint-disable @typescript-eslint/ban-types */
type Primitive = undefined | null | boolean | string | number | Function;
type DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;
type DeepReadonlyObject<T> = {
    readonly [K in keyof T]: DeepReadonly<T[K]>;
};
type DeepReadonlyArray<T> = ReadonlyArray<DeepReadonly<T>>;
type DeepReadonlySet<T> = ReadonlySet<DeepReadonly<T>>;
type DeepReadonly<T> = T extends Primitive ? T : T extends Map<infer K, infer V> ? DeepReadonlyMap<K, V> : T extends object ? DeepReadonlyObject<T> : T extends Array<infer U> ? DeepReadonlyArray<U> : T extends Set<infer M> ? DeepReadonlySet<M> : unknown;
type JSONValue = string | number | boolean | {
    [x: string]: JSONValue;
} | Array<JSONValue>;
type UseState<U> = [
    U,
    (value: U) => void
];
type UseReducer<S, A> = [
    ReducerState<Reducer<S, A>>,
    Dispatch<ReducerAction<Reducer<S, A>>>
];
type Callback<U, V> = (value: U) => V;
type FileSizeUnit = "B" | "KB" | "MB" | "GB" | "TB";
type ReadableFileSize = {
    value: number;
    unit: FileSizeUnit;
};
type TButtonProps = DeepReadonly<{
    /**
     * The variant of the main button design.
     */
    readonly variant?: "primary" | "secondary" | "icon";
    /**
     * How large should the button be?
     */
    readonly size?: "small" | "medium" | "large";
    /**
     * The color of the component, regarding the current theme and following semantic color naming.
     */
    readonly backgroundColor?: "primary" | "secondary" | "success" | "warning" | "error" | "info";
    /**
     * Button label used to convey its action.
     */
    readonly label: string;
    /**
     * If true, the component is disabled.
     */
    readonly disabled?: boolean;
    /**
     * Icon for the icon variant.
     */
    readonly icon?: JSX.Element;
    /**
     * Icon left of label.
     */
    readonly leftIcon?: JSX.Element;
    /**
     * Icon right of label.
     */
    readonly rightIcon?: JSX.Element;
    /**
     * The callback function called when button is clicked.
     * The `onClick` function is an event handler attached to the button just like a normal HTML
     * `<button>`.
     */
    readonly onClick?: () => void;
}>;
/**
 * Primary UI component for user interaction.
 */
declare const Button: React.FC<TButtonProps>;
type TCanvasCreatedCallback = Callback<HTMLCanvasElement, void>;
type TCanvasDestroyedCallback = Callback<void, void>;
type TRenderCanvasCallback = Callback<{
    canvas: HTMLCanvasElement;
    deltaTime: number;
}, void>;
type TCanvasProps = Readonly<{
    /**
     * Width of the canvas.
     */
    readonly width?: number;
    /**
     * Height of the canvas.
     */
    readonly height?: number;
    /**
     * Defines if "touch-action: 'none'" is on the canvas.
     */
    readonly touchActionNone?: boolean;
    /**
     * Disable scrolling on the canvas element so that it doesn't interfere with
     * zoom in/out actions.
     */
    readonly disableScrolling?: boolean;
    /**
     * Specifies if the rendering should be performed.
     */
    readonly animated?: boolean;
    /**
     * Called when canvas is created. Can be used to configure the canvas afterwards.
     */
    readonly onCanvasCreated?: TCanvasCreatedCallback;
    /**
     * Called when canvas is about to be destroyed.
     */
    readonly onCanvasDestroyed?: TCanvasDestroyedCallback;
    /**
     * Called when rendering (if `animated` is set to true)
     */
    readonly onRender?: TRenderCanvasCallback;
}>;
/**
 * Canvas react component.
 */
declare const Canvas: React.FC<TCanvasProps>;
type CardProps = Readonly<{
    /**
     * The background color applied to the final rendering of the card.
     */
    readonly background?: "primary" | "secondary";
    /**
     * Content part, positioned in the center of the card.
     */
    readonly content?: Readonly<JSX.Element>;
    /**
     * Footer part, positioned at the bottom of the card.
     */
    readonly footer?: Readonly<JSX.Element>;
    /**
     * Header part, positioned at the top of the card.
     */
    readonly header?: Readonly<JSX.Element>;
    /**
     * The size of the rendered card.
     * It will be automatically adjusted responsively to the screen size.
     */
    readonly size?: "small" | "medium" | "large";
    /**
     * Whether card has a themed border.
     */
    readonly withBorder?: boolean;
}>;
declare const Card: React.FC<CardProps>;
type FileInputProps = {
    /**
     * The main title of the file input.
     */
    readonly label?: string;
    /**
     * Context information for the user.
     */
    readonly description?: JSX.Element;
    /**
     * Drop one or several files.
     */
    readonly multiple?: boolean;
    /**
     * The list of the accepted formats.
     */
    readonly acceptedFormats?: string[];
    /**
     * The size of the file input area.
     */
    readonly size?: "large" | "medium" | "small";
    /**
     * Make the component in an error state or not.
     */
    readonly error?: boolean;
    /**
     * An error message displayed when the component is in the error state.
     */
    readonly errorMessage?: string;
    /**
     * Callback method called when files are dropped.
     */
    // lint rule bypassed in method props arguments
    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
    readonly onDropped: (files: File[]) => void;
};
// lint rule bypassed while disabling the rule
// eslint-disable-next-line max-lines-per-function
declare const FileInput: React.FC<FileInputProps>;
type Lng = string;
type Language = {
    readonly name: string;
    readonly lng: Lng;
};
type Languages = Language[];
type LanguageSwitcherProps = DeepReadonly<{
    /**
     * The available languages for the application
     */
    readonly languages: Languages;
}>;
declare const LanguageSwitcher: React.FC<LanguageSwitcherProps>;
// svg sprite polyfill
type IconName = "add" | "alert" | "arrow-down" | "arrow-left" | "arrow-right" | "arrow-up" | "calendar" | "chat" | "check" | "clock" | "close" | "cross" | "facebook" | "linkedin" | "meeting" | "menu" | "moon" | "next" | "podcast" | "previous" | "profile" | "search" | "sun" | "twitter" | "wallet";
type IconProps = {
    /**
     * Icon name to use.
     */
    readonly name: IconName;
    /**
     * Icon size in pixels, squared.
     */
    readonly size?: number;
    /**
     * Custom className to add some additional style.
     */
    readonly className?: string;
    /**
     * If `true`, the color is inverted according to the current theme.
     */
    readonly invertColor?: boolean;
};
declare const Icon: React.FC<IconProps>;
type ListProps = {
    /**
     * The elements passed as children of the List component.
     * The expected children are `ListItem` components.
     */
    readonly children: React.ReactNode;
};
/**
 * Primary UI component for display a list of items.
 */
declare const List: React.FC<ListProps>;
type ListItemProps = {
    /**
     * The main title of the item.
     */
    readonly title?: string;
    /**
     * Additional information about the item
     */
    readonly description?: string | JSX.Element;
    /**
     * An element that can provide visual information or allow interactions on the left side.
     */
    readonly leftElement?: JSX.Element;
    /**
     * An element that can provide visual information or allow interactions on the right side.
     */
    readonly rightElement?: JSX.Element;
};
declare const ListItem: React.FC<ListItemProps>;
// svg sprite polyfill
type LogoProps = Readonly<{
    /**
     * The size of the logo, must be determined according to its use and location.
     */
    readonly size?: "x-small" | "small" | "medium" | "large";
    /**
     * The type of the logo, flexible according to use and location.
     */
    readonly type?: "logo" | "logotype" | "logomark" | "slogan";
}>;
declare const Logo: React.FC<LogoProps>;
type ProgressBarProps = {
    /**
     * The progress bar title.
     */
    readonly label?: string;
    /**
     * The start value of the progress bar.
     */
    readonly minValue?: number;
    /**
     * The end value of the progress bar.
     */
    readonly maxValue?: number;
    /**
     * The current value of the progress bar.
     */
    readonly currentValue?: number;
    /**
     * Allows to define how to display the current value.
     *
     * @param currentValue The current value of the progress bar.
     * @return Returns the formatted current value.
     */
    readonly currentValueFormatter?: (currentValue: number) => string;
    /**
     * Allows to define how to display the progress
     *
     * @param currentValue The current value of the progress bar.
     * @param minValue The start value of the progress bar.
     * @param maxValue The end value of the progress bar.
     * @return Returns the formatted progress value.
     */
    readonly progressValueFormatter?: (currentValue: number, minValue?: number, maxValue?: number) => string;
    /**
     * An icon that can provide visual information
     */
    readonly icon?: Readonly<JSX.Element>;
};
/**
 * Returns the current value in string.
 *
 * @param currentValue The current value.
 * @returns The current value in string.
 */
declare const defaultValueFormatter: (currentValue: number) => string;
/**
 * Formats the progression in percentage.
 *
 * @param currentValue The value of the progression.
 * @param minValue The start value of the scale.
 * @param maxValue The end value of the scale.
 * @returns The current percentage progress.
 */
declare const defaultProgressValueFormatter: (currentValue: number, minValue?: number, maxValue?: number) => string;
/**
 * Primary UI component for progress of a treatment.
 */
declare const ProgressBar: React.FC<ProgressBarProps>;
type InputBaseProps = {
    /**
     * Placeholder text.
     */
    readonly placeholder?: string;
    /**
     * Defines the callback called when the input value changes.
     */
    readonly onChange?: (event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
    /**
     * The value of the `input` element, required for a controlled component.
     */
    readonly value?: string | string[];
    /**
     * The default value.
     * Used when the component is not controlled.
     */
    readonly defaultValue?: string | string[];
    /**
     * Indicates if the input area is disabled.
     */
    readonly disabled?: boolean;
    /**
     * If true, the input is displayed in an error state.
     */
    readonly hasError?: boolean;
    /**
     * Pass a ref to the element.
     */
    readonly ref?: RefObject<HTMLInputElement | HTMLTextAreaElement>;
    /**
     * The icon displayed on the right side.
     */
    readonly rightIcon?: JSX.Element;
    /**
     * If true, input becomes immutable
     */
    readonly readOnly?: boolean;
    /**
     * If true, input becomes a text area.
     */
    readonly multiline?: boolean;
    /**
     * If multiline, defines the number of lines of the text area.
     */
    readonly numberOfLines?: number;
    /**
     * If true and multiline, the user can't resize the text area.
     */
    readonly disableAreaResize?: boolean;
    /**
     * Whether input has a themed border.
     */
    readonly withBorder?: boolean;
};
type TextFieldProps = InputBaseProps & {
    /**
     * The size of the TextField.
     * It will be automatically adjusted responsively to the screen size.
     */
    readonly size?: "x-large" | "large" | "medium" | "small" | "x-small";
    /**
     * Displays a message to the user below the input area.
     */
    readonly helperText?: string;
    /**
     * If true, the TextField will take 100% of its parent's size.
     */
    readonly fullWidth?: boolean;
    /**
     * If true, the TextField allows multiline text as a text area.
     */
    readonly multiline?: boolean;
    /**
     * If multiline, defines the number of lines of the text area.
     */
    readonly numberOfLines?: number;
    /**
     * If true and multiline, the user can't resize the text area.
     */
    readonly disableAreaResize?: boolean;
};
declare const TextField: React.FC<TextFieldProps>;
type ThemeProviderProps = DeepReadonly<{
    children: React.ReactNode;
}>;
declare const ThemeProvider: React.FC<ThemeProviderProps>;
type ThemeSwitcherProps = Readonly<{
    /**
     * Tells if the theme should be saved to (and restored from) the local storage.
     */
    readonly saveToLocalStorage?: boolean;
    /**
     * The key to use for fetching the theme from the local storage.
     */
    readonly localStorageKey?: string;
}>;
declare const ThemeSwitcher: React.FC<ThemeSwitcherProps>;
type ToastProps = {
    /**
     * Indicates if the toast must be displayed or not.
     */
    readonly isOpened: boolean;
    /**
     * The severity level of the carried information, influences the final rendering of the toast.
     */
    readonly severityLevel: "error" | "success" | "info" | "warning";
    /**
     * The time in milliseconds that should elapse before automatically closing the toast.
     */
    readonly autoDuration?: number;
    /**
     * An optional title for the toast.
     */
    readonly title?: string;
    /**
     * An optional description for the toast.
     */
    readonly description?: string | JSX.Element;
    /**
     * Event handler called when the open state of the dialog changes.
     */
    readonly onOpenChange?: (isOpened: boolean) => void;
    /**
     * Prevents the toast from closing automatically.
     */
    readonly preventAutoClose?: boolean;
};
declare const Toast: React.FC<ToastProps>;
type TypographyProps = DeepReadonly<{
    /**
     * Prop used to switch out what's being ultimately rendered.
     */
    readonly as?: "div" | "p" | "span" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "pre" | "ul" | "li";
    /**
     * The size of the rendered typography.
     */
    readonly fontSize?: "x-large" | "large" | "medium" | "small" | "x-small";
    /**
     * `brand` (Gotham) is the main font for OKP4 branding,
     * therefore it is mainly used for all UI interfaces.
     * The `secondary` font is Noto Sans Mono.
     */
    readonly fontFamily?: "brand" | "secondary";
    /**
     * The different font weights declared for each font-family.
     */
    readonly fontWeight?: "xlight" | "light" | "bold" | "black";
    /**
     * Sets the appearance of decorative lines on text.
     */
    readonly textDecoration?: "underline";
    /**
     * The color applied to the final rendering of the typography,
     * regarding the current theme and following semantic color naming.
     */
    readonly color?: "text" | "highlighted-text" | "inverted-text" | "invariant-text" | "success" | "warning" | "error" | "info";
    /**
     * Handles the `white-space` property in the element.
     * If true, the text will not wrap, but instead will truncate with a text overflow ellipsis.
     */
    readonly noWrap?: boolean;
    /**
     * The elements passed as children of the Typography component.
     * As an example, directly the text itself.
     */
    readonly children: React.ReactNode;
}>;
declare const Typography: React.FC<TypographyProps>;
type HeaderProps = {
    /**
     * Element positioned first in the reading flow.
     */
    readonly firstElement: JSX.Element;
    /**
     * The list of navigable links that make up the menu.
     */
    readonly navigationMenu?: JSX.Element[];
};
declare const Header: React.FC<HeaderProps>;
type FooterProps = DeepReadonly<{
    /**
     * The languages used for the translation service.
     */
    readonly languages: DeepReadonly<Languages>;
    /**
     * Last element used to render additional element(s).
     */
    readonly lastElement?: DeepReadonly<JSX.Element>;
}>;
declare const Footer: React.FC<FooterProps>;
type StepStatus = "disabled" | "invalid" | "completed" | "active" | "uncompleted";
type StepIndex = number;
type Step = {
    /**
     * The title of the step
     */
    readonly label: string;
    /**
     * The initial status of the step
     */
    readonly status?: StepStatus;
    /**
     * The content of the step
     */
    readonly content?: JSX.Element;
    /**
     * Callback method called when clicking on the next button
     * to validate the step and go to the next one
     */
    readonly onValidate?: () => boolean;
};
type StepperProps = {
    /**
     * The list of the steps
     */
    readonly steps: Step[];
    /**
     * The label of the submit button
     */
    readonly submitButtonLabel?: string;
    /**
     * The label of the reset button
     */
    readonly resetButtonLabel?: string;
    /**
     * The content displayed after submission
     */
    readonly successContent?: JSX.Element;
    /**
     * Callback method called on click on next button
     */
    readonly onNext?: () => void;
    /**
     * Callback method called when clicking on the submit button in the last step
     */
    readonly onSubmit?: () => void;
    /**
     * Callback method called when clicking on the reset button after the last step
     */
    readonly onReset?: () => void;
};
// eslint-disable-next-line max-lines-per-function
declare const Stepper: React.FC<StepperProps>;
type FaucetProps = Readonly<{
    chainId: string;
}>;
// JSX function
// eslint-disable-next-line max-lines-per-function
declare const Faucet: React.FC<FaucetProps>;
type FilePickerProps = Pick<FileInputProps, "label" | "description" | "multiple" | "acceptedFormats" | "size"> & {
    /**
     * Displays a clickable text to delete all selected files.
     */
    readonly showClearAll?: boolean;
};
// eslint-disable-next-line max-lines-per-function
declare const FilePicker: React.FC<FilePickerProps>;
// Need any type for Action to allow Redux to dispatch async Thunks
// eslint-disable-next-line @typescript-eslint/no-explicit-any
type StoreContext = React.Context<ReactReduxContextValue<any>>;
// Need any type for Store, if not, type breaks in the props type
// eslint-disable-next-line @typescript-eslint/no-explicit-any
type StoreParameter = [
    StoreContext,
    Store<any>
];
type StoreProviderProps = DeepReadonly<{
    storeParameters: ImmutableList<StoreParameter>;
    children: React.ReactElement;
}>;
declare const StoreProvider: React.FC<StoreProviderProps>;
declare const asImmutable: <T>(o?: T | undefined) => DeepReadonly<T>;
declare const asMutable: <T, U extends DeepReadonly<T>>(o?: U | undefined) => T;
type Truthy<T> = T extends false | "" | 0 | null | undefined ? never : T;
declare const truthy: <T>(value: T) => value is Truthy<T>;
declare const toPercent: (value: number, min: number, max: number) => number;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
declare const isString: (value: any) => value is string;
declare const compareStrings: (referenceStr: string, compareString: string, 
// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
locales?: string | string[], 
// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
options?: Intl.CollatorOptions | undefined) => number;
type SelectOption = {
    readonly label: string;
    readonly value: string;
    readonly group?: string;
};
declare const sortSelectOptionAsc: (options: Readonly<SelectOption[]>) => SelectOption[];
declare const sortSelectOptionDesc: (options: Readonly<SelectOption[]>) => SelectOption[];
/**
 * Convert a byte size into a more readable value.
 * @param size The size to convert.
 * @returns An object containing the value and the size unit.
 */
declare const toReadableFileSize: (size: number, formatter?: ((size: number) => number) | undefined) => ReadableFileSize;
/**
 * Check if the file has the given MIME type or extension
 * @param file The file to check.
 * @param acceptedFormat The accepted MIME type or extension of the file.
 * @returns A boolean that indicates if the file match the MIME type or the extension.
 */
declare const isFileTypeAccepted: (file: DeepReadonly<File>, acceptedFormat: string) => boolean;
/**
 * Check if each file has one of the MIME types or extensions.
 * @param files The files to check.
 * @param acceptedFormats The accepted formats (MIME type or extension) of the files.
 * @returns A boolean that indicates if the files matches the MIME types or extensions.
 */
declare const areFilesAccepted: (files: DeepReadonly<File[]>, acceptedFormats?: Readonly<string[]>) => boolean;
type SelectInputProps = Pick<InputBaseProps, "placeholder" | "disabled" | "hasError">;
type SelectValue = string | Readonly<string[]>;
type SelectProps = SelectInputProps & {
    /**
     * Defines the callback called when the select value changes.
     */
    readonly onChange: (value: SelectValue) => void;
    /**
     * The value of the select.
     */
    readonly value: SelectValue;
    /**
     * The options list displayed when the select is opened.
     */
    readonly options: Readonly<SelectOption[]>;
    /**
     * If true, allows the user to make a multiple choice.
     * Default to false.
     */
    readonly multiple?: boolean;
    /**
     * The size of the input field.
     * It will be automatically adjusted responsively to the screen size.
     */
    readonly size?: "x-large" | "large" | "medium" | "small" | "x-small";
    /**
     * If true, the select will take 100% of its parent's size.
     */
    readonly fullWidth?: boolean;
    /**
     * Displays a message to the user below the select area.
     */
    readonly helperText?: string;
};
// eslint-disable-next-line max-lines-per-function, @typescript-eslint/prefer-readonly-parameter-types
declare const Select: ({ placeholder, size, disabled, hasError, multiple, options, onChange, fullWidth, value, helperText }: DeepReadonly<SelectProps>) => JSX.Element;
type Theme = "light" | "dark";
type ThemeContextType = Readonly<{
    theme: Theme;
    setTheme: (newTheme: Theme) => void;
}>;
declare const useTheme: () => ThemeContextType;
type UseTranslationResponse = UseI18nTranslationResponse<string>;
declare const useTranslation: (namespace?: string) => UseTranslationResponse;
type TAnimationFrameCallback = (deltaTime: number) => void;
/**
 * A hook to deal with requestAnimationFrame() in React.
 *
 * @param callback the callback function to call when it's time to update the animation.
 * @param animated tells if a requestAnimationFrame
 */
declare const useAnimationFrame: (callback: TAnimationFrameCallback, animated?: boolean) => void;
type Breakpoints = {
    isXSmall: boolean;
    isSmall: boolean;
    isMedium: boolean;
    isLarge: boolean;
    isXLarge: boolean;
};
declare const useBreakpoint: () => Breakpoints;
type ElementSize = Readonly<{
    width: number;
    height: number;
}>;
declare const useElementSize: <T extends HTMLElement = HTMLDivElement>() => [
    ElementSize | null,
    (node: T | null) => void
];
type LocalStorageState = [
    string | null,
    (value: string) => void
];
declare const useLocalStorage: (key: string) => LocalStorageState;
declare const useMediaType: (query: string) => boolean;
type MouseEvent = "mousedown" | "mouseup";
declare const useOnClickOutside: <T extends HTMLElement = HTMLDivElement>(ref: RefObject<T>, handler: Callback<Event, void>, mouseEvent?: MouseEvent) => void;
type KeyboardEventType = "keydown" | "keypress" | "keyup";
declare const useOnKeyboard: <T extends HTMLElement = HTMLDivElement>(handler: Callback<KeyboardEvent, void>, keyboardEvent?: KeyboardEventType, ref?: RefObject<T | null> | undefined) => void;
type Entity<T, V> = {
    readonly id: V;
} & DeepReadonly<T>;
type MediaType = string;
type Id = string;
type Error = Entity<{
    readonly messageKey: string;
    readonly timestamp: Date;
    readonly type: string;
    readonly initiator?: string;
    readonly context?: Record<string, unknown>;
}, Id>;
type ErrorsById = Map<Id, Error>;
interface AppState {
    readonly errors: ErrorsById;
    readonly unseenErrorId: Id;
}
declare const useErrorStore: <State = AppState, Action extends import("redux").Action<any> = any>() => import("redux").Store<State, Action>;
declare const useErrorDispatch: <AppDispatch extends import("redux").Dispatch<any> = import("redux").Dispatch<any>>() => AppDispatch;
declare const useErrorSelector: <TState = unknown, Selected = unknown>(selector: (state: TState) => Selected, equalityFn?: import("react-redux").EqualityFn<Selected> | undefined) => Selected;
interface AppState$0 {
    readonly address: string;
}
declare const useFaucetStore: <State = AppState$0, Action extends import("redux").Action<any> = any>() => import("redux").Store<State, Action>;
declare const useFaucetDispatch: <AppDispatch extends import("redux").Dispatch<any> = import("redux").Dispatch<any>>() => AppDispatch;
declare const useFaucetSelector: <TState = unknown, Selected = unknown>(selector: (state: TState) => Selected, equalityFn?: import("react-redux").EqualityFn<Selected> | undefined) => Selected;
type TaskStatus = "processing" | "success" | "error";
type TaskProgress = {
    min?: number;
    max?: number;
    current?: number;
};
type Task<T = string, I = string> = Entity<{
    readonly creationDate: Date;
    readonly lastUpdateDate: Date;
    readonly type: T;
    readonly status: TaskStatus;
    readonly initiator: string;
    readonly progress?: TaskProgress;
}, I>;
type AppState$1<T = string, I = string> = {
    readonly task: TaskState<T, I>;
    readonly displayedTaskIds: OrderedSet<I>;
};
type TaskState<T = string, I = string> = {
    readonly byId: TaskById<I>;
    readonly byType: TaskByType<T, I>;
};
type TaskById<I = string> = OrderedMap<I, Task>;
type TaskByType<T = string, I = string> = OrderedMap<T, OrderedSet<I>>;
declare const useTaskStore: <State = AppState$1<string, string>, Action extends import("redux").Action<any> = any>() => import("redux").Store<State, Action>;
declare const useTaskDispatch: <AppDispatch extends import("redux").Dispatch<any> = import("redux").Dispatch<any>>() => AppDispatch;
declare const useTaskSelector: <TState = unknown, Selected = unknown>(selector: (state: TState) => Selected, equalityFn?: import("react-redux").EqualityFn<Selected> | undefined) => Selected;
type ChainId = string;
type ConnectionStatus = "connected" | "not connected";
type ConnectionStatuses = Map<ChainId, ConnectionStatus>;
type Algorithm = "secp256k1" | "ed25519" | "sr25519";
type Account = {
    readonly address: string;
    readonly algorithm: Algorithm;
    readonly publicKey: Uint8Array;
};
type Accounts = ImmutableList<Account>;
type AccountsByChainId = Map<ChainId, Accounts>;
interface AppState$2 {
    readonly connectionStatuses: ConnectionStatuses;
    readonly accounts: AccountsByChainId;
}
declare const useWalletStore: <State = AppState$2, Action extends import("redux").Action<any> = any>() => import("redux").Store<State, Action>;
declare const useWalletDispatch: <AppDispatch extends import("redux").Dispatch<any> = import("redux").Dispatch<any>>() => AppDispatch;
declare const useWalletSelector: <TState = unknown, Selected = unknown>(selector: (state: TState) => Selected, equalityFn?: import("react-redux").EqualityFn<Selected> | undefined) => Selected;
type FileEntity<I = string> = Entity<{
    readonly name: string;
    readonly size: number;
    readonly type: MediaType;
    readonly stream: ReadableStream;
}, I>;
type AppState$3<I = string> = {
    readonly file: FileState<I>;
};
type FileState<I = string> = {
    readonly byId: FileById<I>;
    readonly byType: FileByType<I>;
};
type FileById<I = string> = OrderedMap<I, FileEntity>;
type FileByType<I = string> = OrderedMap<string, OrderedSet<I>>;
declare const useFileStore: <State = AppState$3<string>, Action extends import("redux").Action<any> = any>() => import("redux").Store<State, Action>;
declare const useFileDispatch: <AppDispatch extends import("redux").Dispatch<any> = import("redux").Dispatch<any>>() => AppDispatch;
declare const useFileSelector: <TState = unknown, Selected = unknown>(selector: (state: TState) => Selected, equalityFn?: import("react-redux").EqualityFn<Selected> | undefined) => Selected;
declare const ErrorContext: React.Context<ReactReduxContextValue<AppState, any>>;
declare const FaucetContext: React.Context<ReactReduxContextValue<AppState$0, any>>;
declare const TaskContext: React.Context<ReactReduxContextValue<AppState$1<string, string>, any>>;
declare const WalletContext: React.Context<ReactReduxContextValue<AppState$2, any>>;
declare const FileContext: React.Context<ReactReduxContextValue<AppState$3<string>, any>>;
type I18nResource = Readonly<{
    readonly lng: string;
    readonly namespace: string;
    readonly resource: JSONValue;
}>;
declare const loadTranslations: (resources: Array<I18nResource>, overwrite?: boolean) => void;
declare const updateLanguage: (lng: string) => void;
declare const isCurrentLanguage: (lng: string) => boolean;
type ErrorStoreParameters = {
    preloadedState?: AppState$3;
    eventBus: EventBus | null;
};
declare class ErrorStoreBuilder {
    private readonly errorStoreParameters;
    constructor(errorStoreParameters?: DeepReadonly<ErrorStoreParameters>);
    withPreloadedState(preloadedState: DeepReadonly<AppState$3>): ErrorStoreBuilder;
    withEventBus(eventBus: DeepReadonly<EventBus>): ErrorStoreBuilder;
    build(): Store<AppState$3, AnyAction>;
    private invariant;
}
declare const getErrorById: (state: DeepReadonly<AppState$3>, id: Id) => Error | undefined;
declare const hasUnseenError: (state: DeepReadonly<AppState$3>) => boolean;
declare const unseenErrorMessage: (state: DeepReadonly<AppState$3>) => string | undefined;
type ThunkResult<R> = ThunkAction<R, AppState$3, undefined, Action>;
declare const acknowledgeError: () => ThunkResult<Promise<void>>;
declare const clearError: (id: Id) => ThunkResult<Promise<void>>;
declare const clearErrors: () => ThunkResult<Promise<void>>;
declare const reportError: (error: Error) => ThunkResult<Promise<void>>;
type TaskStoreParameters = {
    preloadedState?: AppState$3;
    eventBus: EventBus | null;
};
declare class TaskStoreBuilder {
    private readonly taskStoreParameters;
    constructor(taskStoreParameters?: DeepReadonly<TaskStoreParameters>);
    withPreloadedState(preloadedState: DeepReadonly<AppState$3>): TaskStoreBuilder;
    withEventBus(eventBus: DeepReadonly<EventBus>): TaskStoreBuilder;
    build(): Store<AppState$3, AnyAction>;
    private invariant;
}
type Status = "processing" | "success" | "error";
declare const getTaskStatusById: (state: DeepReadonly<AppState$3>, id: string) => Status | undefined;
declare const getTaskIdsByType: (state: DeepReadonly<AppState$3>, type: string) => OrderedSet<string> | undefined;
// Get only first displayed Id by a specified type and status
declare const getDisplayedTaskIdByTypeAndStatus: (state: DeepReadonly<AppState$3>, type: string, status: Status) => string | undefined;
type AcknowledgeTask<I = string> = {
    id: I;
};
type Progress = {
    min?: number;
    max?: number;
    current?: number;
};
type Status$0 = "processing" | "success" | "error";
type AmendTaskStatus<I = string> = {
    readonly id: I;
    readonly timestamp?: Date;
    readonly status: Status$0;
};
type RegisterTask<T = string, I = string> = {
    readonly id: I;
    readonly timestamp?: Date;
    readonly type: T;
    readonly initiator: string;
    readonly progress?: Progress;
};
type RemoveTask<I = string> = {
    id: I;
};
type RemoveTasks<I = string> = I[];
type ProgressBounds = Omit<Progress, "current">;
type ConfigureTaskProgressBounds<I = string> = {
    readonly id: I;
    readonly timestamp?: Date;
    readonly progressBounds: ProgressBounds;
};
type SetTaskProgressValue<I = string> = {
    readonly id: I;
    readonly timestamp?: Date;
    readonly progressValue: number;
};
type Progress$0 = {
    min?: number;
    max?: number;
    current?: number;
};
type ProgressBounds$0 = Omit<Progress$0, "current">;
type ThunkResult$0<R> = ThunkAction<R, AppState$3, undefined, Action>;
declare const acknowledgeTask: (acknowledgeTaskPayload: Readonly<AcknowledgeTask>) => ThunkResult$0<Promise<void>>;
declare const removeTask: (removeTaskPayload: DeepReadonly<RemoveTask>) => ThunkResult$0<Promise<void>>;
declare const removeTasks: (removeTasksPayload?: DeepReadonly<RemoveTasks>) => ThunkResult$0<Promise<void>>;
declare const registerTask: (registerTaskPayload: DeepReadonly<RegisterTask>) => ThunkResult$0<Promise<void>>;
declare const amendTaskStatus: (amendTaskStatusPayload: DeepReadonly<AmendTaskStatus>) => ThunkResult$0<Promise<void>>;
declare const configureTaskProgressBounds: (configureTaskProgressBoundsPayload: DeepReadonly<ConfigureTaskProgressBounds>) => ThunkResult$0<Promise<void>>;
declare const setTaskProgressValue: (setTaskProgressValuePayload: DeepReadonly<SetTaskProgressValue>) => ThunkResult$0<Promise<void>>;
type FaucetPort = {
    readonly requestFunds: (address: string) => Promise<string>;
};
interface Dependencies {
    readonly faucetGateway: FaucetPort;
}
type ThunkResult$1<R> = ThunkAction<R, AppState$3, Dependencies, Action>;
type FaucetStoreParameters = {
    dependencies: Dependencies | null;
    eventBus: EventBus | null;
    preloadedState?: AppState$3;
};
declare class FaucetStoreBuilder {
    private readonly faucetStoreParameters;
    constructor(faucetStoreParameters?: DeepReadonly<FaucetStoreParameters>);
    withDependencies(dependencies: Dependencies): FaucetStoreBuilder;
    withEventBus(eventBus: DeepReadonly<EventBus>): FaucetStoreBuilder;
    withPreloadedState(preloadedState: DeepReadonly<AppState$3>): FaucetStoreBuilder;
    build(): Store<AppState$3, AnyAction>;
    private invariant;
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    private isDependencies;
}
declare const faucetTaskType = "faucet#request-funds";
declare const requestFunds: (address: string) => ThunkResult$1<Promise<void>>;
declare const setAddress: (address: string) => ThunkResult$1<Promise<void>>;
type WalletRegistryPort = {
    readonly get: (id: WalletId) => Wallet;
    readonly names: () => readonly string[];
};
type Wallet = {
    readonly id: () => WalletId;
    readonly isAvailable: () => boolean;
    readonly connect: (chainId: ChainId) => Promise<void>;
    readonly isConnected: () => boolean;
    readonly getAccounts: (chainId: ChainId) => Promise<Accounts>;
};
type WalletId = string;
interface Dependencies$0 {
    readonly walletRegistryGateway: WalletRegistryPort;
}
type ThunkResult$2<R> = ThunkAction<R, AppState$3, Dependencies$0, Action>;
type WalletStoreParameters = {
    dependencies: Dependencies$0 | null;
    eventBus: EventBus | null;
    preloadedState?: AppState$3;
};
declare class WalletStoreBuilder {
    private readonly walletStoreParameters;
    constructor(walletStoreParameters?: DeepReadonly<WalletStoreParameters>);
    withDependencies(dependencies: Dependencies$0): WalletStoreBuilder;
    withEventBus(eventBus: DeepReadonly<EventBus>): WalletStoreBuilder;
    withPreloadedState(preloadedState: DeepReadonly<AppState$3>): WalletStoreBuilder;
    build(): Store<AppState$3, AnyAction>;
    private invariant;
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    private isDependencies;
}
declare const enableWallet: (walletId: WalletId, chainId: ChainId) => ThunkResult$2<Promise<void>>;
type FileStoreParameters = {
    eventBus: EventBus | null;
    preloadedState?: AppState$3;
};
declare class FileStoreBuilder {
    private readonly fileStoreParameters;
    constructor(fileStoreParameters?: DeepReadonly<FileStoreParameters>);
    withEventBus(eventBus: DeepReadonly<EventBus>): FileStoreBuilder;
    withPreloadedState(preloadedState: DeepReadonly<AppState$3>): FileStoreBuilder;
    build(): Store<AppState$3, AnyAction>;
    private invariant;
}
type RemoveFile<I = string> = {
    id: I;
};
type ThunkResult$3<R> = ThunkAction<R, AppState$3, undefined, Action>;
declare const removeFile: (removeFilePayload: DeepReadonly<RemoveFile>) => ThunkResult$3<Promise<void>>;
declare const removeAllFiles: () => ThunkResult$3<Promise<void>>;
type StoreFile<I = string> = {
    id: I;
    name: string;
    size: number;
    type: MediaType;
    stream: ReadableStream;
};
type StoreFiles<I = string> = StoreFile<I>[];
declare const storeFiles: (storeFilesPayload: DeepReadonly<StoreFiles>) => ThunkResult$3<Promise<void>>;
type FileDescriptor = {
    readonly id: string;
    readonly name: string;
    readonly size: number;
    readonly type: MediaType;
};
declare const getFiles: (state: DeepReadonly<AppState$3>) => FileDescriptor[];
declare const createEventBusInstance: () => EventBus;
declare class HTTPFaucetGateway implements FaucetPort {
    private readonly faucetUrl;
    constructor(faucetUrl: string);
    requestFunds: (address: string) => Promise<string>;
}
declare class WalletRegistryGateway implements WalletRegistryPort {
    private wallets;
    readonly get: (id: string) => Wallet;
    readonly register: (...wallets: readonly Wallet[]) => void;
    readonly clear: () => void;
    readonly names: () => readonly string[];
}
type Currency = {
    readonly coinDenom: string;
    readonly coinMinimalDenom: string;
    readonly coinDecimals: number;
    readonly coinGeckoId?: string;
    readonly coinImageUrl?: string;
};
type CW20Currency = Currency & {
    readonly type: "cw20";
    readonly contractAddress: string;
};
type Secret20Currency = Currency & {
    readonly type: "secret20";
    readonly contractAddress: string;
    readonly viewingKey: string;
};
type IBCCurrency = Currency & {
    readonly paths: {
        portId: string;
        channelId: string;
    }[];
    readonly originChainId: string | undefined;
    readonly originCurrency: Currency | CW20Currency | Secret20Currency | undefined;
};
type AppCurrency = Currency | CW20Currency | Secret20Currency | IBCCurrency;
type ChainInfo = {
    readonly rpc: string;
    readonly rest: string;
    readonly chainId: string;
    readonly chainName: string;
    readonly stakeCurrency: Currency;
    readonly walletUrl?: string;
    readonly walletUrlForStaking?: string;
    readonly bip44: BIP44;
    readonly alternativeBIP44s?: BIP44[];
    readonly bech32Config: Bech32Config;
    readonly currencies: AppCurrency[];
    readonly feeCurrencies: Currency[];
    readonly coinType?: number;
    readonly gasPriceStep?: {
        low: number;
        average: number;
        high: number;
    };
    readonly features?: string[];
    readonly beta?: boolean;
};
type BIP44 = {
    readonly coinType: number;
};
type Bech32Config = {
    readonly bech32PrefixAccAddr: string;
    readonly bech32PrefixAccPub: string;
    readonly bech32PrefixValAddr: string;
    readonly bech32PrefixValPub: string;
    readonly bech32PrefixConsAddr: string;
    readonly bech32PrefixConsPub: string;
};
declare class KeplrWalletGateway implements Wallet {
    private _isConnected;
    private readonly chainInfos;
    constructor(chainInfos?: DeepReadonly<Array<ChainInfo>>);
    readonly isAvailable: () => boolean;
    readonly isConnected: () => boolean;
    readonly connect: (chainId: ChainId) => Promise<void>;
    readonly getAccounts: (chainId: ChainId) => Promise<Accounts>;
    readonly id: () => WalletId;
    private readonly setConnected;
    private readonly suggestChain;
}
export { TButtonProps, Button, TCanvasCreatedCallback, TCanvasDestroyedCallback, TRenderCanvasCallback, TCanvasProps, Canvas, CardProps, Card, FileInputProps, FileInput, LanguageSwitcherProps, LanguageSwitcher, IconName, IconProps, Icon, ListProps, List, ListItemProps, ListItem, LogoProps, Logo, ProgressBarProps, defaultValueFormatter, defaultProgressValueFormatter, ProgressBar, TextFieldProps, TextField, ThemeProvider, ThemeSwitcherProps, ThemeSwitcher, Toast, TypographyProps, Typography, HeaderProps, Header, FooterProps, Footer, StepStatus, StepIndex, Step, StepperProps, Stepper, FaucetProps, Faucet, FilePickerProps, FilePicker, StoreContext, StoreParameter, StoreProviderProps, StoreProvider, SelectValue, SelectProps, Select, useTheme, UseTranslationResponse, useTranslation, TAnimationFrameCallback, useAnimationFrame, Breakpoints, useBreakpoint, ElementSize, useElementSize, LocalStorageState, useLocalStorage, useMediaType, MouseEvent, useOnClickOutside, KeyboardEventType, useOnKeyboard, useErrorStore, useErrorDispatch, useErrorSelector, useFaucetStore, useFaucetDispatch, useFaucetSelector, useTaskStore, useTaskDispatch, useTaskSelector, useWalletStore, useWalletDispatch, useWalletSelector, useFileStore, useFileDispatch, useFileSelector, ErrorContext, FaucetContext, TaskContext, WalletContext, FileContext, I18nResource, loadTranslations, updateLanguage, isCurrentLanguage, Language, Languages, ErrorStoreParameters, ErrorStoreBuilder, getErrorById, hasUnseenError, unseenErrorMessage, acknowledgeError, clearError, clearErrors, reportError, TaskStoreParameters, TaskStoreBuilder, getTaskStatusById, getTaskIdsByType, getDisplayedTaskIdByTypeAndStatus, AcknowledgeTask, AmendTaskStatus, RegisterTask, RemoveTask, RemoveTasks, ProgressBounds$0 as ProgressBounds, ConfigureTaskProgressBounds, SetTaskProgressValue, acknowledgeTask, removeTask, removeTasks, registerTask, amendTaskStatus, configureTaskProgressBounds, setTaskProgressValue, FaucetStoreParameters, FaucetStoreBuilder, faucetTaskType, requestFunds, setAddress, WalletStoreParameters, WalletStoreBuilder, enableWallet, FileStoreParameters, FileStoreBuilder, removeFile, removeAllFiles, storeFiles, FileDescriptor, getFiles, createEventBusInstance, HTTPFaucetGateway, WalletRegistryGateway, Currency, CW20Currency, Secret20Currency, IBCCurrency, AppCurrency, ChainInfo, BIP44, Bech32Config, KeplrWalletGateway, truthy, isString, toPercent, toReadableFileSize, isFileTypeAccepted, areFilesAccepted, sortSelectOptionAsc, sortSelectOptionDesc, compareStrings, asImmutable, asMutable };
export type { Theme, ThemeContextType, DeepReadonly, UseState, UseReducer, Entity, Truthy, SelectOption };
