/// <reference types="react" />
/// <reference types="node" />
import * as React$1 from 'react';
import React__default, { ElementType, Context, CSSProperties, PropsWithChildren, ComponentType, ReactNode, SyntheticEvent, ReactElement, ComponentProps } from 'react';
import * as _mui_material from '@mui/material';
import { ButtonProps as ButtonProps$1, BoxProps, TextFieldProps, PaperProps, ButtonTypeMap, SvgIconProps, TooltipProps as TooltipProps$1, DialogTitleProps, DialogContentProps, DialogProps, DialogActionsProps } from '@mui/material';
import { BlockInstance, BlockDefinition, Dimensions, EntityProperties, EntityProperty, EntityDTO, Entity, IconValue, Kind, Plan } from '@kapeta/schemas';
import { InstanceStatus, Task } from '@kapeta/ui-web-context';
import { DOMElement } from '@kapeta/ui-web-utils';
import * as react_use_lib_useAsyncFn from 'react-use/lib/useAsyncFn';
import { AsyncState } from 'react-use/lib/useAsync';
import { Asset, TypeLike, HTTPTransport, RESTMethod, SchemaKind, Size } from '@kapeta/ui-web-types';
import { AutocompleteProps as AutocompleteProps$1 } from '@mui/material/Autocomplete';
import { TextFieldProps as TextFieldProps$1 } from '@mui/material/TextField';
import { ToastOptions } from 'react-toastify';
import { ParserTracer } from 'peggy';
import { AgGridReactProps, AgReactUiProps } from 'ag-grid-react/lib/shared/interfaces';
import { ColDef } from 'ag-grid-community';
import * as _mui_system from '@mui/system';
import { SxProps } from '@mui/system';
import { Theme } from '@mui/material/styles';
import { MuiOtpInputProps } from 'mui-one-time-password-input';
import { ITerminalOptions, ITerminalInitOnlyOptions } from 'xterm';
import * as _emotion_styled from '@emotion/styled';
import { DateTime, DateTimeFormatOptions, ToRelativeOptions } from 'luxon';
import { SvgIconProps as SvgIconProps$1 } from '@mui/material/SvgIcon';
import * as UAParser from 'ua-parser-js';

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare enum StandardIcons {
    VIEW = "fad fa-eye",
    DELETE = "fad fa-trash",
    EDIT = "fad fa-pencil",
    SAVE = "fad fa-save",
    CANCEL = "fa fa-times"
}
/**
 * @deprecated Use MUI Button instead
 */
declare enum ButtonStyle {
    PRIMARY = "primary",
    PRIMARY_SHINE = "primary_shine",
    SECONDARY = "secondary",
    DEFAULT = "default",
    DANGER = "danger"
}
/**
 * @deprecated Use MUI Button instead
 */
declare enum ButtonType {
    BUTTON = "button",
    SUBMIT = "submit",
    RESET = "reset"
}
/**
 * @deprecated Use MUI Button instead
 */
declare enum ButtonShape {
    HEXAGON = "hexagon",
    ICON = "icon",
    SQUARE = "square"
}
/**
 * @deprecated Use MUI Button instead
 */
declare enum ButtonSize {
    ICON = 26,
    SMALL = 90,
    MEDIUM = 160,
    LARGE = 240,
    HUGE = 320
}
interface ButtonProps {
    text: string;
    width: number;
    disabled?: boolean;
    style?: ButtonStyle;
    type?: ButtonType;
    shape?: ButtonShape;
    onClick?: () => void;
}
/**
 * @deprecated Use MUI Button instead
 */
declare const Button: (props: Omit<ButtonProps, 'width'> & {
    width?: number;
}) => React__default.JSX.Element;
interface LogoProps {
    text: string;
    logo: string;
    href: string;
    width?: number;
}
/**
 *
 * @deprecated Use MUI Button instead
 */
declare const LogoButton: (props: LogoProps) => React__default.JSX.Element;
interface ActionsProps {
    children: any;
}
declare const Actions: (props: ActionsProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type KapButtonProps<C extends ElementType = 'button'> = ButtonProps$1<C, {
    component?: C;
}> & {
    loading?: boolean;
};
declare const KapButton: (props: KapButtonProps<ElementType>) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const BlockInstanceName: (props: {
    onChange?: (instanceName: string) => void;
}) => React__default.JSX.Element;
declare const BlockStatus: () => React__default.JSX.Element;
declare const BlockName: () => React__default.JSX.Element;
declare const BlockHandle: () => React__default.JSX.Element;
declare const BlockVersion: () => React__default.JSX.Element;
declare const BlockLayout: (props: {
    status?: InstanceStatus;
    readOnly?: boolean;
    instance: BlockInstance;
    definition: BlockDefinition;
    children: React__default.ReactNode;
    onInstanceNameChange?: (instanceName: string) => void;
}) => React__default.JSX.Element;

interface BlockContextData {
    readOnly?: boolean;
    definition?: BlockDefinition | undefined;
    instance?: BlockInstance | undefined;
    status?: InstanceStatus | undefined;
    callbacks: {
        onInstanceNameChange?: (name: string) => void;
    };
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const useBlock: () => BlockContextData;

interface DnDDragProps {
    children: any;
    type: string;
    value: any;
    horizontal?: boolean;
    vertical?: boolean;
    disabled?: boolean;
    zoom?: number;
    copyElm?: () => JSX.Element;
    onDragStart?: () => void;
    onDragMove?: (dimensions: Dimensions) => boolean;
    onDragEnd?: (dimensions: Dimensions) => boolean;
    dragCopy?: boolean;
    container?: DOMElement | string;
}
declare class DnDDrag extends React__default.Component<DnDDragProps> {
    static contextType: React__default.Context<DnDContextData>;
    context: React__default.ContextType<DnDContextType>;
    private elm;
    private target;
    private draggable?;
    componentDidMount(): void;
    componentDidUpdate(): void;
    render(): React__default.JSX.Element;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface DraggableContext<T> {
    containerElement: () => DOMElement | null;
    onDragStart: (drag: T) => void;
    onDragMove: (position: Dimensions, dragRect: ClientRect, drag: T) => void;
    onDragEnd: (position: Dimensions, dragRect: ClientRect, drag: T) => void;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface DnDContextData extends DraggableContext<DnDDrag> {
    scrollTop: number;
    scrollLeft: number;
    overflowX?: boolean;
    overflowY?: boolean;
    zoom?: number;
    onDropZoneRemoved: (dropZone: DnDDrop) => void;
    onDropZoneCreated: (dropZone: DnDDrop) => void;
    container?: DnDContainer;
}
interface DnDContextType extends Context<DnDContextData> {
}

interface DnDDropProps {
    children: any;
    droppable?: (value: any) => boolean;
    onDrop: (type: string, value: any, dragDimensions: Dimensions) => void;
    onDrag?: (type: string, value: any, dragDimensions: Dimensions) => void;
    type: string | string[];
}
interface DnDDropState {
    dragging: boolean;
    hovering: boolean;
}
declare class DnDDrop extends React__default.Component<DnDDropProps, DnDDropState> {
    static contextType: React__default.Context<DnDContextData>;
    context: React__default.ContextType<DnDContextType>;
    private elm;
    constructor(props: DnDDropProps);
    matchesType(drag: DnDDrag): boolean;
    componentDidMount(): void;
    componentWillUnmount(): void;
    private getDimensionsForElement;
    onDragStart(drag: DnDDrag): void;
    onDragEnd(dimensions: Dimensions, dragRect: ClientRect, drag: DnDDrag): boolean;
    onDragMove(dimensions: Dimensions, dragRect: ClientRect, drag: DnDDrag): boolean;
    clearMoveState(): void;
    clearState(): void;
    render(): React__default.JSX.Element;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface DnDContainerProps {
    children: any;
    overflowX?: boolean;
    overflowY?: boolean;
    zoom?: number;
}
interface DnDContainerState {
    scrollLeft: number;
    scrollTop: number;
    zoom?: number;
}
declare class DnDContainer extends React__default.Component<DnDContainerProps, DnDContainerState> {
    private elm;
    private dropZones;
    private currentDropZones;
    constructor(props: DnDContainerProps);
    private getDropZonesFor;
    onDropZoneCreated(dropZone: DnDDrop): void;
    onDropZoneRemoved(dropZone: DnDDrop): void;
    onDragStart(drag: DnDDrag): void;
    onDragMove(dimensions: Dimensions, dragRect: ClientRect, drag: DnDDrag): void;
    onDragEnd(dimensions: Dimensions, dragRect: ClientRect, drag: DnDDrag): void;
    componentDidMount(): void;
    private updateScroll;
    calculateStyle(existingStyle?: CSSProperties): React__default.CSSProperties;
    getElement(): DOMElement;
    render(): React__default.JSX.Element;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const DRAGGING_HANDLE_CSS = "dragging-handle";
declare const DRAGGING_SOURCE_CSS = "dragging-source";
interface DraggableOptions<T> {
    elm: DOMElement;
    dragCopy?: boolean;
    horizontal?: boolean;
    vertical?: boolean;
    disabled?: boolean;
    handle?: string;
    target?: DOMElement;
    container?: Element;
    context?: DraggableContext<T>;
    zoom?: number;
    overflowX?: boolean;
    overflowY?: boolean;
    onDragStart?: () => void;
    onDragMove?: (dimensions: Dimensions) => boolean;
    onDragEnd?: (dimensions: Dimensions) => boolean;
}
declare class Draggable<T> {
    private options;
    private elm;
    private handle;
    private target;
    private draggingTarget;
    private dragging;
    private startPosition;
    private lastMouseMoveEvent;
    private lastScrollPoint;
    private initialSize;
    private mouseElementOffset;
    private containerDimensions;
    private svgContainer?;
    private enabledAxis;
    private item;
    constructor(item: T, options: DraggableOptions<T>);
    start(): void;
    stop(): void;
    private getContainerElement;
    private getDocumentBody;
    private getWindow;
    private isSVG;
    private calculateDimensions;
    private getZoomLevel;
    private updateContainerDimensions;
    private getGlobalScroll;
    private getGlobalScrollDelta;
    /**
     * Gets the mouse position translated down to the local coordinate system of the element
     * @param evt
     */
    private getTranslatedMousePosition;
    private handleMouseDown;
    private handleScroll;
    private handleMouseMove;
    private updateFromMousePosition;
    private handleMouseUp;
    private updateDraggingTarget;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface IDEntry {
    id: string;
    type: EntityProperty;
}
type IDList = IDEntry[];
type EntityMap = {
    [from: string]: MappedEntity;
};
interface EntityMapperProps {
    from: EntityProperties;
    fromEntities: EntityDTO[];
    to: EntityProperties;
    toEntities: EntityDTO[];
    onChange: (entityMap: EntityMap) => void;
}
declare enum MappedEntityType {
    AUTO = "AUTO"
}
interface MappedEntity {
    to: string;
    type?: MappedEntityType;
}
interface EntityMapperState {
    mapping: EntityMap;
}
declare class EntityMapper extends React__default.Component<EntityMapperProps, EntityMapperState> {
    constructor(props: EntityMapperProps);
    toTargetFlatList(properties: EntityProperties, parentId?: string): IDList;
    toTargetLastListEntry(id: string, entry: EntityProperty, parentId?: string): IDList;
    renderObject(properties: EntityProperties, parentId?: string): React__default.JSX.Element;
    renderEntry(id: string, entry: EntityProperty): React__default.ReactNode;
    getMapping(id: string): string;
    updateMapping(id: string, value: string): void;
    render(): React__default.JSX.Element;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type Value = {
    [key: string]: any;
};
interface EntityBlockInstanceResource {
    name: string;
    portType: string;
}
interface EntityBlockInstance {
    id: string;
    name: string;
    providers: EntityBlockInstanceResource[];
}
interface Props$n {
    entities: Entity[];
    instances?: EntityBlockInstance[];
    value: Value;
    onChange: (value: Value) => void;
}
declare const EntityEditor: (props: Props$n) => React__default.JSX.Element;
interface FormProps$1 {
    entities: Entity[];
    instances?: EntityBlockInstance[];
    name: string;
}
declare const EntityEditorForm: (props: FormProps$1) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface CheckboxProps {
    value?: boolean;
    disabled?: boolean;
    onChange?: (userInput: boolean) => void;
    onClick?: () => void;
}

declare const Checkbox: (props: CheckboxProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type Props$m = {
    /**
     * Add a wrapper div around the buttons with gap between them and right alignment.
     */
    addWrapperDiv?: boolean;
    children: React__default.ReactNode;
} & BoxProps;
declare const FormButtons: (formButtonProps: Props$m) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */
type AsyncValidationContext = {
    cancel: () => void;
    promise: Promise<any>;
};
type ValidationContext = {
    cancel: () => void;
    errors: Promise<string[]>;
    hasAsync: boolean;
};
type AsyncValidatorFunction = (fieldName: string, value: any) => AsyncValidationContext | void;
type ValidatorFunction = AsyncValidatorFunction | string;
type ValidatorList = ValidatorFunction[];
type ValidatorListUnresolved = ValidatorList | string | ValidatorFunction;
declare const Validators: {
    [key: string]: ValidatorFunction;
};
declare function normaliseValidators(validation?: ValidatorListUnresolved): ValidatorList;
declare function useValidation(active: boolean, validation: ValidatorListUnresolved, name: string, value: any): {
    errors: react_use_lib_useAsyncFn.AsyncState<string[]>;
    hasAsync: boolean;
};
/**
 * Debounce an async validator - e.g. if you want to wait for the user to stop typing before validating
 *
 * @param delay
 * @param func
 */
declare function debouncedValidator(delay: number, func: AsyncValidatorFunction): AsyncValidatorFunction;
declare function applyValidation(validation: ValidatorListUnresolved, name: string, value: any): ValidationContext;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare enum Type {
    DATE = "date",
    EMAIL = "email",
    NUMBER = "number",
    PASSWORD = "password",
    TEXT = "text"
}
type PickedMuiTextFieldProps = Pick<TextFieldProps, 'variant' | 'onFocus' | 'onBlur' | 'autoFocus' | 'autoComplete'>;
interface FormInputProps extends PickedMuiTextFieldProps {
    onChange?: (inputName: string, userInput: any) => void;
    type?: Type;
}
declare const FormInput: (props: any) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare enum StatusType {
    ERROR = "error",
    OK = "ok"
}
interface FormFieldControllerProps<V = any> {
    name: string;
    value?: V;
    defaultValue?: V;
    help?: string;
    validation?: ValidatorListUnresolved;
    label?: string;
    disabled?: boolean;
    readOnly?: boolean;
    autoFocus?: FormInputProps['autoFocus'];
    variant?: FormInputProps['variant'];
    onFocus?: FormInputProps['onFocus'];
    onBlur?: FormInputProps['onBlur'];
    autoComplete?: FormInputProps['autoComplete'];
    className?: HTMLElement['className'];
}
interface FormFieldController<V = any> {
    name: string;
    value?: V;
    filled: boolean;
    touched: boolean;
    required: boolean;
    errors: AsyncState<string[]>;
    processing: boolean;
    showError: boolean;
    status: StatusType;
    help?: string;
    label?: string;
    disabled: boolean;
    readOnly: boolean;
    autoFocus?: FormInputProps['autoFocus'];
    variant?: FormInputProps['variant'];
    onFocus?: FormInputProps['onFocus'];
    onBlur?: FormInputProps['onBlur'];
    autoComplete?: FormInputProps['autoComplete'];
    className?: HTMLElement['className'];
}
declare const useIsFormSubmitAttempted: () => boolean;
declare const useFormFieldController: <T = any>(props: FormFieldControllerProps<T>) => FormFieldController<T>;
declare const withFormFieldController: <V = any, P = any>(component: (props: P, controller: FormFieldController<V>) => React__default.JSX.Element) => (props: P & FormFieldControllerProps<V>) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface Props$l extends FormFieldControllerProps<string> {
    namespaces: string[];
}
declare const AssetNameInput: (props: Props$l) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface AssetVersionSelectorEntry {
    ref: string;
    kind: string;
    title?: string;
    icon?: IconValue;
}
declare function fromAssetsToAssetVersionSelectorEntries(assets: Asset[]): AssetVersionSelectorEntry[];
declare function fromAssetToAssetVersionSelectorEntry(asset: Asset): AssetVersionSelectorEntry;
interface Props$k extends FormFieldControllerProps<string> {
    assetTypes: AssetVersionSelectorEntry[];
}
declare const AssetVersionSelector: (props: Props$k) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type ResetListener = (value: any) => void;
interface FormContextData {
    valid: boolean;
    validators?: ValidatorList;
    processing: boolean;
    isDirty: boolean;
    container?: FormContainer;
    onReadyStateChanged: (childName: any, ready: boolean) => void;
    onValueChanged: (name: string, value: any) => void;
    onReset(name: string, callback: ResetListener): () => void;
}
interface FormContextType extends Context<FormContextData> {
}
declare const FormContext: FormContextType;
declare function useFormContextField<T = any>(fieldName: string, resetHandler?: ResetListener): {
    get(defaultValue?: T): T;
    set(value: T): void;
    valid(): void;
    invalid(): void;
};
declare function FormContextWatcher({ onChange }: {
    onChange: (context: FormContextData) => void;
}): any;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type FormChangeHandler = (formState: FormStateChangeEvent) => void;
interface FormStateChangeEvent {
    type: string;
    value: any;
}
type FormData = {
    [key: string]: any;
};
interface FormContainerProps<TData> {
    onSubmit?: () => void | Promise<void>;
    onReset?: () => void;
    validators?: ValidatorList;
    initialValue?: TData;
    onSubmitData?: (data: TData) => void | Promise<void>;
    onChange?: (data: TData) => void;
    children: any;
}
interface State<TData> {
    formData: TData;
    readyStates: {
        [key: string]: boolean;
    };
    valid: boolean;
    processing: boolean;
    isDirty: boolean;
}
declare class FormContainer<TData extends FormData = any> extends React__default.Component<FormContainerProps<TData>, State<TData>> {
    static contextType: FormContextType;
    context: React__default.ContextType<FormContextType>;
    container: HTMLDivElement | null;
    private readonly submitClickHandler;
    private readonly resetClickHandler;
    private readonly changeHandlers;
    private readonly resetListeners;
    constructor(props: FormContainerProps<TData>);
    getValue(name: string): any;
    private onValueChanged;
    private onReadyStateChanged;
    private isValid;
    private emitFormStateChange;
    onFormStateChanged(handler: FormChangeHandler): () => void;
    private addResetListener;
    private renderFormContainer;
    private processingWhile;
    private shouldSubmitForm;
    submit(): Promise<void>;
    private emitChange;
    reset(): void;
    private handleResetClick;
    private handleSubmitClick;
    private handleKeyPress;
    private bindButtons;
    private hasParentContainer;
    private focusFirstUnready;
    componentDidMount(): void;
    componentDidUpdate(prevProps: FormContainerProps<TData>): void;
    render(): React__default.JSX.Element;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface FormReadyHandlerProps {
    name: string;
    ready: boolean;
    children: any;
}
/**
 * For sending a custom ready state to a form container.
 * Ready state means whether parts of a form is valid or not.
 */
declare class FormReadyHandler extends React__default.Component<FormReadyHandlerProps> {
    static contextType: FormContextType;
    context: React__default.ContextType<FormContextType>;
    private readyState?;
    private updateReadyState;
    componentDidMount(): void;
    componentDidUpdate(): void;
    componentWillUnmount(): void;
    render(): React__default.JSX.Element;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */
interface FieldProps$1 {
    name: string;
    value?: any;
    onChange: (name: string, value: any) => void;
    disabled?: boolean;
}
interface Props$j {
    name: string;
    component: (props: FieldProps$1) => JSX.Element;
}
declare const FormFieldHandler: (props: Props$j) => JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const FormSelect: (props: any) => React__default.JSX.Element;

interface Props$i {
    onChange?: (inputName: string, userInput: any) => void;
}
declare const FormTextarea: (props: Props$i & FormFieldControllerProps<any>) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare enum FormFieldType {
    DATE = "date",
    EMAIL = "email",
    NUMBER = "number",
    PASSWORD = "password",
    STRING = "string",
    TEXT = "text",
    CHECKBOX = "checkbox",
    RADIO = "radio",
    ENUM = "enum",
    ENUM_MULTI = "enum_multi"
}
interface SharedFormFieldProps {
    label?: string;
    validation?: any[];
    help?: string;
    options?: string[] | {
        [key: string]: string;
    };
    disabled?: boolean;
    readOnly?: boolean;
    autoFocus?: FormInputProps['autoFocus'];
    variant?: FormInputProps['variant'];
    onFocus?: FormInputProps['onFocus'];
    onBlur?: FormInputProps['onBlur'];
    autoComplete?: FormInputProps['autoComplete'];
}
interface FormFieldProps extends SharedFormFieldProps {
    name: string;
    type?: FormFieldType;
}
declare const FormField: (props: FormFieldProps) => React__default.JSX.Element;

interface Props$h {
    name: string;
    label?: string;
    value?: any;
    validation?: any[];
    help?: string;
    disabled?: boolean;
    onChange?: (inputName: string, userInput: any) => void;
}
declare const FormCheckbox: (props: Props$h & FormFieldControllerProps<any>) => React__default.JSX.Element;

interface Props$g {
    options: string[] | {
        [key: string]: string;
    };
    onChange?: (inputName: string, userInput: any) => void;
}
declare const FormRadioGroup: (props: Props$g & FormFieldControllerProps<any>) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type AutocompleteProps<Option> = Omit<AutocompleteProps$1<Option, boolean, boolean, boolean>, 'renderInput'> & Pick<TextFieldProps$1, 'name' | 'label' | 'placeholder'> & {
    hidePopupIndicator?: boolean;
};
declare function Autocomplete<Option>(props: AutocompleteProps<Option>): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type FormAutocompleteProps<Option> = Omit<AutocompleteProps<Option>, 'value'>;
declare function FormAutocomplete<Option>({ name, onChange, ...otherAutocompleteProps }: FormAutocompleteProps<Option> & {
    name: string;
}): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type DefaultFormLayoutProps = PropsWithChildren<{
    gap?: BoxProps['gap'];
    sx?: BoxProps['sx'];
}>;
declare const DefaultFormLayout: ({ children, gap, sx }: DefaultFormLayoutProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface LoaderProps {
    load: () => Promise<JSX.Element>;
}
declare const Loader: (props: LoaderProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare enum LoaderType {
    CIRCLE = "circle",
    DUAL_RING = "dual-ring",
    FACEBOOK = "facebook",
    HEART = "heart",
    RING = "ring",
    ROLLER = "roller",
    DEFAULT = "default",
    ELLIPSIS = "ellipsis",
    GRID = "grid",
    HOURGLASS = "hourglass",
    RIPPLE = "ripple",
    SPINNER = "spinner"
}
interface Props$f {
    loader?: () => Promise<any>;
    loading?: boolean;
    text?: string;
    type?: LoaderType;
    children?: any;
}
declare const SimpleLoader: (props: Props$f) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface Props$e {
    list: any[];
    empty?: string;
    item: (item: any) => any;
}
declare const ElementList: (props: Props$e) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const emptyStateIconNames: readonly ["default", "card", "invoice", "usage", "launch", "launchpad"];
type EmptyStateIconName = (typeof emptyStateIconNames)[number];
interface EmptyStateIconProps {
    icon: EmptyStateIconName;
    size: number;
}
declare const EmptyStateIcon: (props: EmptyStateIconProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface EmptyStateBoxProps extends Omit<PaperProps, 'title'> {
    title: React__default.ReactNode;
    description?: React__default.ReactNode;
    actions?: React__default.ReactNode;
    icon?: EmptyStateIconName;
    size?: number;
}
declare const EmptyStateBox: (props: EmptyStateBoxProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface StackContainerProps {
    currentPageId?: string;
    onPageRequest: (pageId: string) => void;
    children: any;
}
interface StackPageInfo {
    id: string;
    title: string;
    disabled?: boolean;
    count?: number;
    countClass?: string;
}
interface StackContainerState {
    pages: StackPageInfo[];
}
declare class StackContainer extends React$1.Component<StackContainerProps, StackContainerState> {
    private container;
    constructor(props: StackContainerProps);
    private handlePageAdded;
    private handlePageRemoved;
    private handlePageUpdated;
    render(): React$1.JSX.Element;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface StackContextData {
    currentStackId?: string;
    onStackAdded: (id: string, title: string) => void;
    onStackUpdated: (id: string, title: string) => void;
    onStackRemoved: (id: string) => void;
}
interface StackContextType extends Context<StackContextData> {
}

interface TabPageProps$1 {
    id: string;
    title: string;
    children: any;
}
declare class StackPage extends React$1.Component<TabPageProps$1, any> {
    static contextType: React$1.Context<StackContextData>;
    context: React$1.ContextType<StackContextType>;
    componentDidMount(): void;
    componentWillUnmount(): void;
    render(): React$1.JSX.Element;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface TabContainerProps {
    defaultTab?: string;
    onTabChange?: (tabId: string) => void;
    currentTabId?: string;
    children: any;
}
interface TabPageInfo {
    id: string;
    title: string;
    disabled?: boolean;
    count?: number;
    countClass?: string;
}
interface TabContainerState {
    currentPageId?: string;
    pages: TabPageInfo[];
}
declare class TabContainer extends React$1.Component<TabContainerProps, TabContainerState> {
    constructor(props: TabContainerProps);
    private isControlled;
    private getCurrentPageId;
    private setCurrentPage;
    private handlePageAdded;
    private handlePageRemoved;
    private handlePageUpdated;
    render(): React$1.JSX.Element;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface TabContextData {
    currentTabId?: string;
    onTabAdded: (id: string, title: string) => void;
    onTabUpdated: (id: string, title: string) => void;
    onTabRemoved: (id: string) => void;
}
interface TabContextType extends Context<TabContextData> {
}

interface TabPageProps {
    id: string;
    title: string;
    children: any;
}
declare class TabPage extends React$1.Component<TabPageProps, any> {
    static contextType: React$1.Context<TabContextData>;
    context: React$1.ContextType<TabContextType>;
    componentDidMount(): void;
    componentWillUnmount(): void;
    render(): React$1.JSX.Element;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface SVGTextProps$1 {
    value: string;
    maxWidth: number;
    maxHeight: number;
    lineHeight: number;
    maxChars: number;
    maxLines: number;
    className?: string;
    x: number;
    y: number;
    onChange?: (value: string) => void;
}
declare function SVGAutoSizeText(props: SVGTextProps$1): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */
interface SVGButtonProps {
    x: number;
    y: number;
    style?: any;
    opacity?: number;
    onClick?: () => void;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare function SVGButtonAdd(props: SVGButtonProps): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare function SVGButtonDelete(props: SVGButtonProps): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare function SVGButtonEdit(props: SVGButtonProps): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const SVGButtonWarning: (props: SVGButtonProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare function SVGButtonInspect(props: SVGButtonProps): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface SVGTextProps {
    value: string;
    maxWidth: number;
    className?: string;
    x?: number;
    y?: number;
}
declare function SVGText(props: SVGTextProps): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface ToastProps {
    title: string;
    message: string;
    type: ToastType;
}
declare enum ToastType {
    ALERT = "alert",
    SUCCESS = "success",
    DANGER = "danger"
}
declare const ToastContainer: () => React$1.JSX.Element;
declare const Toast: (props: ToastProps) => React$1.JSX.Element;
declare const showToasty: (props: ToastProps, options?: ToastOptions) => void;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare enum DetailSize {
    SMALL = "small",
    FULL = "full"
}
type Data = {
    [key: string]: any;
};
interface DetailProps {
    children: any;
    size?: DetailSize;
    editable?: boolean;
    data: Data;
    onChange?: (name: string, value: any, data: Data) => any;
}
declare const Detail: (props: DetailProps) => React__default.JSX.Element;
declare enum RowType {
    CUSTOM = "custom",
    SIMPLE = "simple",
    LIST = "list"
}
interface DetailRowProps {
    label: string;
    name?: string;
    children: any;
    rowType?: RowType;
}
declare const DetailRow: (props: DetailRowProps) => React__default.JSX.Element;
interface DetailRowValueProps {
    name: string;
    label: string;
    fixed?: boolean;
    validation?: any;
}
declare const DetailRowValue: (props: DetailRowValueProps) => React__default.JSX.Element;
interface DetailRowListValueEntryProps {
    name: string;
    typeName: string;
    validation?: any;
    originalValue: any;
    entryValue: any;
    index: number;
    processing: boolean;
    editable: boolean;
    onCancel: () => void;
}
declare const DetailRowListValueEntry: (props: DetailRowListValueEntryProps) => React__default.JSX.Element;
interface DetailRowListValueProps extends DetailRowValueProps {
    typeName: string;
}
declare const DetailRowListValue: (props: DetailRowListValueProps) => React__default.JSX.Element;
interface DetailButtonsProps {
    children: any;
}
declare const DetailButtons: (props: DetailButtonsProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface ActionType {
    icon: string;
    color: ButtonTypeMap['props']['color'];
    on: (entry: any) => any;
}
interface Props$d {
    entry: any;
    title: string;
    actions?: ActionType[];
    properties: {
        [key: string]: {
            type: string;
            label: string;
        };
    };
}
declare const ListElement: (props: Props$d) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface Props$c {
    data: any[];
    emptyText?: string;
    title: string;
    actions?: ActionType[];
    properties: {
        [key: string]: {
            type: string;
            label: string;
        };
    };
}
declare const List: (props: Props$c) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface Props$b {
    children?: any;
}
declare const DefaultContext: (props: Props$b) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */
declare const DSL_LANGUAGE_ID = "kapeta-dsl";
interface DSLAnnotation {
    arguments?: string[];
    type: string;
}
interface DSLTypeComplex {
    name: string;
    generics?: string[];
    list?: boolean;
}
type DSLType = DSLTypeComplex | string;
interface DSLDefaultValue {
    type: 'reference' | 'literal' | 'enum';
    value: string | number | boolean | null;
}
interface PEGLocationCoord {
    offset: number;
    line: number;
    column: number;
}
interface PEGLocation {
    start: PEGLocationCoord;
    end: PEGLocationCoord;
}
interface PEGValidationEntity<T = any> {
    type: string;
    location: PEGLocation;
    data: T;
}
interface DSLDataTypeProperty {
    type: DSLType;
    name: string;
    defaultValue?: DSLDefaultValue | null;
    properties?: DSLDataTypeProperty[];
    annotations?: DSLAnnotation[];
    description?: string;
}
interface DSLParameter {
    name: string;
    type: DSLType;
    annotations?: DSLAnnotation[];
}
declare enum DSLEntityType {
    DATATYPE = "datatype",
    ENUM = "enum",
    METHOD = "method",
    COMMENT = "comment"
}
interface DSLEntityBase {
    type: DSLEntityType;
}
interface DSLRichEntity extends DSLEntityBase {
    name: string;
    annotations?: DSLAnnotation[];
    description?: string;
}
interface DSLEnum extends DSLRichEntity {
    type: DSLEntityType.ENUM;
    values: string[];
}
interface DSLDataType extends DSLRichEntity {
    type: DSLEntityType.DATATYPE;
    properties: DSLDataTypeProperty[];
}
interface DSLMethod extends DSLRichEntity {
    type: DSLEntityType.METHOD;
    returnType: DSLType;
    parameters?: DSLParameter[];
}
interface DSLComment extends DSLEntityBase {
    type: DSLEntityType.COMMENT;
    text: string;
}
type DSLEntity = DSLEnum | DSLDataType | DSLMethod | DSLComment;
interface DSLResult {
    code: string;
    errors?: [];
    entities?: DSLEntity[];
}
interface DSLOptions {
    rest?: boolean;
    types?: boolean;
    methods?: boolean;
    validTypes?: string[];
    stringableTypes?: string[];
    ignoreSemantics?: boolean;
}
interface DSLLanguageOptions extends DSLOptions {
    parameterAnnotations?: string[];
    methodAnnotations?: string[];
    typeAnnotations?: string[];
    fieldAnnotations?: string[];
}
declare function toStandardType(type: DSLType): DSLTypeComplex;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface TypeDefinition {
    name: string;
    description: string;
}
type DSLFormEditorProps<T> = Omit<T, 'value' | 'onChange'> & {
    name: string;
    defaultValue?: DSLResult;
};
/**
 * Types that can easily be converted to or from strings (E.g. in paths and similar)
 */
declare const STRINGABLE_TYPES: TypeDefinition[];
declare const BUILT_IN_TYPES: TypeDefinition[];
declare const REST_METHOD_ANNOTATIONS: TypeDefinition[];
declare const METHOD_ANNOTATIONS: TypeDefinition[];
declare const PARAMETER_ANNOTATIONS: TypeDefinition[];
declare const CONFIG_FIELD_ANNOTATIONS: TypeDefinition[];

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type SchemaMethods = {
    [p: string]: RESTMethod;
};
declare namespace DSLConverters {
    function asDSLType(type: string): DSLType;
    function fromDSLType(type: DSLType): string;
    function fromSchemaType(type?: TypeLike): string;
    function toSchemaType(dslType: DSLType): TypeLike;
    function toSchemaEntity(entity: DSLEntity): Entity | undefined;
    function fromSchemaEntity(entity: Entity): DSLEntity | undefined;
    function fromSchemaProperties(properties: EntityProperties): DSLDataTypeProperty[];
    function toSchemaProperties(properties: DSLDataTypeProperty[]): EntityProperties;
    function fromSchemaTransport(transport: string): "@Path" | "@Header" | "@Query" | "@Body";
    function toSchemaTransport(transport: string): HTTPTransport;
    function fromSchemaMethods(methods: SchemaMethods): DSLMethod[];
    function toSchemaMethods(methods: DSLMethod[]): SchemaMethods;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const DSLWriter: {
    write(entities: DSLEntity[]): string;
};

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface SoftError {
    type: string;
    endColumn: number;
    endLineNumber: number;
    startColumn: number;
    startLineNumber: number;
    message: string;
}
interface DSLParserOptions extends DSLLanguageOptions {
    startRule?: string;
    tracer?: ParserTracer;
    softErrorHandler?: (error: SoftError) => void;
    validator?: (object: any) => void;
}
declare const DSLParser: {
    parse(code: string, options?: DSLParserOptions): DSLResult;
};

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface DSLEditorProps extends DSLLanguageOptions {
    value?: DSLResult | string;
    readOnly?: boolean;
    validator?: (object: any) => void;
    onChange?: (structure: DSLResult) => any;
    onCodeChange?: (code: string) => any;
    onError?: (err: any) => any;
}
declare const DSLEditor: (props: DSLEditorProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface MethodEditorProps {
    value?: DSLResult | string;
    onChange?: (structure: DSLResult) => any;
    onCodeChange?: (code: string) => any;
    onError?: (err: any) => any;
    readOnly?: boolean;
    restMethods?: boolean;
    validTypes?: string[];
}
declare const MethodEditor: (props: MethodEditorProps) => React__default.JSX.Element;
declare const MethodEditorField: (props: DSLFormEditorProps<MethodEditorProps>) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface DataTypeEditorProps {
    value?: DSLResult | string;
    onChange?: (structure: DSLResult) => any;
    onCodeChange?: (code: string) => any;
    onError?: (err: any) => any;
    readOnly?: boolean;
    validTypes?: string[];
}
declare const DataTypeEditor: (props: DataTypeEditorProps) => React__default.JSX.Element;
declare const DataTypeEditorField: (props: DSLFormEditorProps<DataTypeEditorProps>) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const TYPE_INSTANCE = "Instance";
declare const TYPE_INSTANCE_PROVIDER = "InstanceProvider";
interface ConfigurationEditorProps {
    value?: DSLResult | string;
    readOnly?: boolean;
    onChange?: (structure: DSLResult) => any;
    onCodeChange?: (code: string) => any;
    onError?: (err: any) => any;
    validTypes?: string[];
}
declare const ConfigurationEditor: (props: ConfigurationEditorProps) => React__default.JSX.Element;
declare const ConfigurationEditorField: (props: DSLFormEditorProps<DataTypeEditorProps>) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare enum DataGridTheme {
    ALPINE = "alpine",
    ALPINE_DARK = "alpine-dark",
    BALHAM = "balham",
    BALHAM_DARK = "balham-dark",
    MATERIAL = "material"
}
interface DataGridProps<T> extends AgGridReactProps<T>, AgReactUiProps<T> {
    theme?: DataGridTheme;
    dataLoader?: () => Promise<any[]>;
}
declare function DataGrid<TData = any>(props: DataGridProps<TData>): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface Props$a<T> extends DataGridProps<T> {
    onDataRowSelected?: (data: T) => any;
    onDataRowDeselected?: () => any;
}
declare function DataList<T = any>(props: Props$a<T>): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface ExtendedColDef<T extends any> extends ColDef<T> {
    showInTable?: boolean;
    headerName: string;
    field: string;
}
interface Props$9<T> {
    theme?: DataGridTheme;
    rowData?: T[];
    dataLoader?: () => Promise<any[]>;
    columnDefs: ExtendedColDef<T>[];
}
declare function DataListDetails<T = any>(props: Props$9<T>): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const initApplication: (Application: ComponentType) => void;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */
declare const asyncTimeout: (ms: number) => Promise<unknown>;
declare const asyncInterval: (callback: () => Promise<any>, ms: number) => {
    resource: NodeJS.Timeout;
    cancel(): void;
};
declare const asDelayed: <T = any>(data: T, ms: number) => Promise<T>;
declare const withDelay: <T = any>(func: () => Promise<T>, ms: number) => Promise<T>;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */
declare function createHexagon(width: number, height: number, pointSize: number): string;

/*****************************************************************************
 *                                                                            *
 *  SVG Path Rounding Function                                                *
 *  Copyright (C) 2014 Yona Appletree                                         *
 *                                                                            *
 *  Licensed under the Apache License, Version 2.0 (the "License");           *
 *  you may not use this file except in compliance with the License.          *
 *  You may obtain a copy of the License at                                   *
 *                                                                            *
 *      http://www.apache.org/licenses/LICENSE-2.0                            *
 *                                                                            *
 *  Unless required by applicable law or agreed to in writing, software       *
 *  distributed under the License is distributed on an "AS IS" BASIS,         *
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
 *  See the License for the specific language governing permissions and       *
 *  limitations under the License.                                            *
 *                                                                            *
 *****************************************************************************/
/**
 * SVG Path rounding function. Takes an input path string and outputs a path
 * string where all line-line corners have been rounded. Only supports absolute
 * commands at the moment.
 *
 * @param pathString The SVG input path
 * @param radius The amount to round the corners, either a value in the SVG
 *               coordinate space, or, if useFractionalRadius is true, a value
 *               from 0 to 1.
 * @param useFractionalRadius If true, the curve radius is expressed as a
 *               fraction of the distance between the point being curved and
 *               the previous and next points.
 * @returns A new SVG path string with the rounding
 */
declare function roundPathCorners(pathString: string, radius: number, useFractionalRadius: boolean): string;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */
declare const globalObject: any;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type TaskGetter = (taskId: string, cb?: (task: Task) => void | Promise<void>) => TaskState;
interface DesktopContextData {
    version?: string;
    valid: boolean;
    getTask?: TaskGetter;
}
declare const DesktopContext: Context<DesktopContextData>;
declare const useDesktop: () => DesktopContextData;
interface DesktopContainerProps extends PropsWithChildren {
    version?: string;
    taskGetter?: TaskGetter;
}
declare const DesktopContainer: (props: DesktopContainerProps) => React__default.JSX.Element;
interface TaskState {
    task: Task | null;
    active: boolean;
    ready: boolean;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */
type ColorRGB = [number, number, number];
declare const createVerticalScrollShadow: (opacity?: number, backgroundColor?: ColorRGB, shadowColor?: ColorRGB) => {
    overflowY: string;
    overflowX: string;
    background: string;
    backgroundRepeat: string;
    backgroundColor: string;
    backgroundSize: string;
    backgroundAttachment: string;
};

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface Props$8 extends PropsWithChildren {
    sx?: SxProps<Theme>;
}
declare const InfoBox: (props: Props$8) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface Props$7 {
    light?: boolean;
    width?: number;
    height?: number;
}
declare const Logo: (props: Props$7) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface PageProps {
    title?: string;
    introduction?: string;
    children: any;
    /**
     * @deprecated The `type` prop is deprecated (not used anymore)
     */
    type?: string;
}
declare const Page: ({ title, introduction, children }: PageProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface OTPCodeProps {
    name?: string;
    value?: string | null;
    ['data-value']?: string;
    onChange?: (otp: string) => void;
}

/**
 * @deprecated Use OTPInput instead
 */
declare const OTPCode: (props: OTPCodeProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type OTPInputProps = MuiOtpInputProps;
declare const OTPInput: (props: OTPInputProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */
interface AuthScope {
    id: string;
    name: string;
    enabled?: boolean;
    description?: string;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type AuthScopesFieldProps = {
    name: string;
    scopes: AuthScope[];
};
declare const AuthScopesField: (props: AuthScopesFieldProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type AuthScopesListProps = {
    scopes: AuthScope[];
    editable?: boolean;
    onChange?: (scopes: AuthScope[]) => void;
    onHoverScope: (scope: AuthScope | null) => void;
};
declare const AuthScopesList: ({ scopes, editable, onChange, onHoverScope }: AuthScopesListProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface KindIconProps {
    kind: string;
    icon?: IconValue;
    size?: number;
    title?: string;
}
declare const KindIcon: (props: KindIconProps) => React__default.JSX.Element;
interface KindIconTextProps extends KindIconProps {
    title: string;
}
declare const KindIconText: (props: KindIconTextProps) => React__default.JSX.Element;
interface AssetKindIconProps {
    asset: Kind;
    size?: number;
}
declare const AssetKindIcon: (props: AssetKindIconProps) => React__default.JSX.Element;
declare const AssetKindIconText: (props: AssetKindIconProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const authProviderNames: readonly ["google", "microsoft", "github"];
type AuthProviderIconProps = {
    /**
     * The name of the auth provider
     */
    name: (typeof authProviderNames)[number];
    /**
     * The size of the icon in px (default is 24)
     */
    size?: number;
    /**
     * Override the colors of the paths in the SVG
     */
    color?: string;
};
declare const AuthProviderIcon: ({ name, size, color }: AuthProviderIconProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const InfinityIcon: React__default.ForwardRefExoticComponent<Omit<SvgIconProps<"svg", {}>, "ref"> & React__default.RefAttributes<SVGSVGElement>>;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const PromoIcon: React__default.ForwardRefExoticComponent<Omit<SvgIconProps<"svg", {}>, "ref"> & React__default.RefAttributes<SVGSVGElement>>;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface DonutProgressIconProps {
    size?: 'small' | 'medium' | 'large';
    color: string;
    loading: boolean;
    value?: number;
}
declare const DonutProgressIcon: React__default.ForwardRefExoticComponent<DonutProgressIconProps & React__default.RefAttributes<HTMLDivElement>>;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare enum AvatarResultType {
    RAW = 0,
    DATA_URL = 1
}
interface Props$6 {
    url: string;
    onSave: (file: AvatarFileInfo) => Promise<void> | void;
    fallbackIcon?: string;
    size?: number;
    resultType?: AvatarResultType;
    sync?: boolean;
    maxFileSize?: number;
    readOnly?: boolean;
    disabled?: boolean;
}
interface AvatarFileInfo {
    name: string;
    url: string;
    size: number;
    mimeType: string;
    data: string | ArrayBuffer;
}
declare const AvatarEditor: (props: Props$6) => React__default.JSX.Element;
interface FormProps extends FormFieldControllerProps<IconValue> {
    fallbackIcon?: string;
    onChange?: (inputName: string, userInput: IconValue) => void | Promise<void>;
    maxFileSize?: number;
}
declare const FormAvatarEditor: (props: FormProps) => React__default.JSX.Element;
interface FieldProps {
    name: string;
    label: string;
    help?: string;
    fallbackIcon?: string;
    validation?: ValidatorListUnresolved;
    disabled?: boolean;
    maxFileSize?: number;
}
declare const FormAvatarEditorField: (props: FieldProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface XTermStream {
    write(data: string): void;
    on(cb: (line: string) => void): () => void;
}
interface Props$5 {
    terminalOptions?: ITerminalOptions & ITerminalInitOnlyOptions;
    lines?: string[];
    stream?: XTermStream;
    onData?: (data: string) => void;
}
declare const escapeSequence: (str: string) => string;
declare const XTerm: (props: Props$5) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare function getInitialsForName(name: string): string;
interface Props$4 {
    name?: string | undefined;
    size?: number;
}
declare const UserAvatar: (props: Props$4) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type AssetFetcher = (name: string, version: string) => Promise<AssetDisplay | null>;
declare enum CoreTypes {
    CORE = "core/core",
    BLOCK_TYPE = "core/block-type",
    BLOCK_TYPE_OPERATOR = "core/block-type-operator",
    BLOCK_GROUP = "core/block-type-group",
    PLAN = "core/plan",
    LANGUAGE_TARGET = "core/language-target",
    DEPLOYMENT_TARGET = "core/deployment-target",
    DEPLOYMENT = "core/deployment",
    PROVIDER_INTERNAL = "core/resource-type-internal",
    PROVIDER_OPERATOR = "core/resource-type-operator",
    PROVIDER_EXTENSION = "core/resource-type-extension"
}
declare enum ActivityType {
    ASSET_CREATED = "asset_created",
    ASSET_DELETED = "asset_deleted",
    ASSET_UPDATED = "asset_updated"
}
interface Activity {
    created: Date;
    message: string;
    type: string | ActivityType;
    author: Author;
}
interface Author {
    name: string;
    handle: string;
}
interface Version {
    id: string;
    current?: boolean;
    created: Date;
    commit: string;
    author: Author;
}
interface Branch {
    id: string;
    version: Version;
}
interface AssetVersionInfo {
    branches?: Branch[];
    primary: Version[];
}
interface DockerDetails {
    name?: string;
    primary: string;
    tags: string[];
}
interface NPMDetails {
    name: string;
    version: string;
    registry: string;
}
interface MavenDetails {
    groupId: string;
    artifactId: string;
    version: string;
    registry: string;
}
interface YAMLDetails {
    name: string;
    version: string;
}
interface AssetStats {
    stars: number;
    deployed: number;
    downloads: number;
}
interface AssetArtifactInfo<T> {
    type: string;
    details: T;
}
interface AssetRepositoryInfo {
    type: 'git' | 'none';
    main: boolean;
    branch: string;
    commit: string;
    details: {
        url: string;
        remote: string;
        path: string;
    };
}
interface AssetCoreDisplay {
    version: string;
    content: SchemaKind;
}
interface AssetSimpleDisplay extends AssetCoreDisplay {
    checksum?: string;
    createdBy?: string;
    created?: Date;
    lastModifiedBy?: string;
    lastModified?: Date;
}
interface Dependency {
    type: 'Kind' | 'Providers' | 'Consumers' | 'Language target' | 'Deployment target' | 'Blocks' | 'Plan';
    name: string;
}
interface AssetDisplay<T = any> extends AssetSimpleDisplay {
    repository?: AssetRepositoryInfo;
    artifact?: AssetArtifactInfo<T>;
    readme: {
        type: string;
        content: string;
    };
    dependencies?: Dependency[];
    dependants?: Dependency[];
    downloadCount?: number;
    rating?: number;
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const CORE_PREFIX = "core/";
declare function isExtensionKind(kind: string): boolean;
declare function getIdentifier(asset: AssetCoreDisplay): string;
declare function getShortKind(asset: AssetCoreDisplay): string;
declare function renderRepository(repository: AssetRepositoryInfo): React__default.JSX.Element;
declare function renderArtifact(artifact: AssetArtifactInfo<any>): React__default.JSX.Element;
declare function isPublic(content: SchemaKind): boolean;
declare function renderDatetime(date: Date | number): string;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const sortingOptions: {
    '-lastModified': string;
    lastModified: string;
    'content.metadata.title': string;
    '-content.metadata.title': string;
    '-downloadCount': string;
    downloadCount: string;
    '-rating': string;
    rating: string;
};
type Sorting = keyof typeof sortingOptions;
interface AssetSortSelectProps {
    value: Sorting;
    onChange: (sorting: Sorting) => void;
    options?: Sorting[];
}
declare function AssetSortSelect(props: AssetSortSelectProps): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const AssetTypes: {
    readonly PLAN: readonly [CoreTypes.PLAN];
    readonly BLOCK: readonly [];
    readonly PROVIDERS: readonly [CoreTypes.BLOCK_TYPE, CoreTypes.BLOCK_TYPE_OPERATOR, CoreTypes.PROVIDER_INTERNAL, CoreTypes.PROVIDER_OPERATOR, CoreTypes.PROVIDER_EXTENSION, CoreTypes.LANGUAGE_TARGET, CoreTypes.DEPLOYMENT_TARGET];
    readonly ALL: readonly string[];
};
type AssetType = keyof typeof AssetTypes;
interface AssetTypeFilterProps {
    value: AssetType;
    onChange: (assetType: AssetType) => void;
    options?: AssetType[];
}
declare function AssetTypeFilter(props: AssetTypeFilterProps): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare enum AssetInstallStatus {
    NOT_INSTALLED = 1,
    UPGRADABLE = 2,
    INSTALLED = 3
}
interface InstallerService {
    install(assetRef: string): Promise<void>;
    get(assetRef: string): Promise<AssetInstallStatus>;
    uninstall?: (assetRef: string) => Promise<void>;
    onChange?: (assetRef: string, cb: () => void | Promise<void>) => () => void;
}
interface Props$3 {
    asset: AssetDisplay;
    type: 'icon' | 'button' | 'chip';
    service?: InstallerService;
    subscriptions?: boolean;
    contextHandle?: string;
    forceLoading?: boolean;
}
declare const AssetInstallButton: (props: Props$3) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type BlockHubDetailsPreviewer = (asset: AssetDisplay, size: Size) => React__default.ReactNode;
interface BlockhubDetailsProps {
    asset: AssetDisplay;
    service?: InstallerService;
    fetcher: AssetFetcher;
    versionInfo?: AssetVersionInfo;
    tabId?: 'general' | 'dependencies' | 'versions' | string;
    onTabChange: (tabId: 'general' | 'dependencies' | 'versions') => void;
    onBackAction?: () => void;
    previewRenderer?: BlockHubDetailsPreviewer;
    disableNavigation?: boolean;
    onAssetClick?: (asset: AssetDisplay) => void;
    linkMaker?: (fullName: string, version: string) => string;
    subscriptions?: boolean;
    contextHandle?: string;
}
declare function BlockhubDetails(props: BlockhubDetailsProps): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface BlockhubGridProps {
    title?: string;
    tooltip?: ReactNode;
    filter?: AssetType;
    onFilterChange: (filter: AssetType) => void;
    assets: AsyncState<AssetDisplay[]>;
    renderAsset: (asset: AssetDisplay) => React__default.ReactNode;
}
declare function BlockhubGridContainer(props: BlockhubGridProps): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare function BlockhubSidebar(props: React__default.PropsWithChildren): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare function BlockhubStats(props: {
    stats: {
        rating?: number;
        downloads?: number;
    };
}): React__default.JSX.Element;
declare const coreNames: Record<CoreTypes, string>;
declare const getNameForKind: (kind: string) => string;
declare function DependencyKindLabel(props: {
    dependency: {
        name: string;
    };
    fetcher: AssetFetcher;
}): React__default.JSX.Element;
interface BlockhubTileProps {
    title: string;
    handle: string;
    description: string;
    version?: string;
    icon?: React__default.ReactNode;
    actionButton?: React__default.ReactNode;
    assetKindLabel?: React__default.ReactNode;
    languageTargetLabel?: React__default.ReactNode[];
    href?: string;
    onClick?: () => void;
    selected?: boolean;
    stats?: {
        rating?: number;
        downloads?: number;
    };
}
declare function BlockhubTile(props: BlockhubTileProps): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface BlockhubTileActionButtonProps {
    label: string;
    onClick: (evt: SyntheticEvent) => void | Promise<void>;
    icon?: ReactElement;
    disabled?: boolean;
    menuItems?: {
        label: string;
        onClick: (evt: SyntheticEvent) => void;
    }[];
    color?: 'primary' | 'secondary' | 'default';
}
declare function BlockhubTileActionButton(props: BlockhubTileActionButtonProps): React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare enum BlockhubMode {
    PAGE = 0,
    MODAL_STANDALONE = 1,
    MODAL_SELECTION = 2
}
declare enum BlockhubCategory {
    INSTALLED = 0,
    OWN = 1,
    COMMUNITY = 2,
    PREMIUM = 3
}
interface Props$2 {
    installerService?: InstallerService;
    plan?: Asset<Plan>;
    fetcher: AssetFetcher;
    assets: AsyncState<AssetDisplay[]>;
    mode: BlockhubMode;
    category?: BlockhubCategory;
    onCategoryChange?: (category: BlockhubCategory) => void;
    selection?: AssetDisplay[];
    disableNavigation?: boolean;
    onSelectionChange?: (selection: AssetDisplay[]) => void;
    onAssetClick?: (asset: AssetDisplay) => void;
    linkMaker?: (asset: AssetDisplay) => string;
    subscriptions?: boolean;
    contextHandle?: string;
    filter?: AssetType;
    onFilterChange: (filter: AssetType) => void;
}
declare const Blockhub: React__default.ForwardRefExoticComponent<Props$2 & React__default.RefAttributes<HTMLDivElement>>;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface Props$1 {
    open: boolean;
    plan?: Asset<Plan>;
    installerService: InstallerService;
    fetcher: AssetFetcher;
    assets: AsyncState<AssetDisplay[]>;
    previewRenderer?: BlockHubDetailsPreviewer;
    category?: BlockhubCategory;
    onCategoryChange?: (category: BlockhubCategory) => void;
    onSelect?: (selection: AssetDisplay[]) => void;
    onClose: () => void;
    filter?: AssetType;
    onFilterChange: (filter: AssetType) => void;
}
declare const BlockhubModal: (props: Props$1) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface KeyValueRowProps {
    children: any;
}
declare const KeyValueRow: (props: KeyValueRowProps) => React__default.JSX.Element;
interface KeyValueProps {
    label: string;
    value: any;
}
declare const KeyValue: (props: KeyValueProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface GraphProps extends AssetVersionInfo {
}
declare const VersionGraph: (props: GraphProps) => React__default.JSX.Element;
interface BranchContainerProps {
    branch: string;
    children: any;
}
declare const BranchContainer: (props: BranchContainerProps) => React__default.JSX.Element;
interface ElementProps {
    version: Version;
}
declare const VersionElement: (props: ElementProps) => React__default.JSX.Element;
interface ListProps {
    branch: string;
    versions: Version[];
}
declare const VersionList: (props: ListProps) => React__default.JSX.Element;

type TooltipProps = TooltipProps$1 & {
    /**
     * The maximum width of the tooltip.
     * @default 220
     */
    maxWidth?: number;
    /**
     * If `true`, adds an arrow to the tooltip.
     * @default true
     */
    arrow?: boolean;
    /**
     * Tooltip placement
     * @default 'top'
     */
    placement?: TooltipProps$1['placement'];
};
declare const Tooltip: _emotion_styled.StyledComponent<TooltipProps$1 & {
    /**
     * The maximum width of the tooltip.
     * @default 220
     */
    maxWidth?: number;
    /**
     * If `true`, adds an arrow to the tooltip.
     * @default true
     */
    arrow?: boolean;
    /**
     * Tooltip placement
     * @default 'top'
     */
    placement?: TooltipProps$1['placement'];
} & _mui_system.MUIStyledCommonProps<_mui_material.Theme>, {}, {}>;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface ConfirmOptions {
    title?: React.ReactNode;
    titleProps?: DialogTitleProps;
    description?: React.ReactNode;
    content?: React.ReactNode | null;
    contentProps?: DialogContentProps;
    confirmationText?: React.ReactNode;
    icon?: React.ReactNode;
    cancellationText?: React.ReactNode;
    dialogProps?: Omit<DialogProps, 'open'>;
    dialogActionsProps?: DialogActionsProps;
    confirmationButtonProps?: ButtonProps$1;
    cancellationButtonProps?: ButtonProps$1;
    allowClose?: boolean;
    confirmationKeyword?: string;
    confirmationKeywordTextFieldProps?: TextFieldProps;
    hideCancelButton?: boolean;
    buttonOrder?: string[];
}

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface ConfirmProviderProps {
    children: React__default.ReactNode;
    defaultOptions?: ConfirmOptions;
}
declare const ConfirmProvider: ({ children, defaultOptions }: ConfirmProviderProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const useConfirm: () => (options?: ConfirmOptions) => Promise<boolean>;
declare const useConfirmIcon: (icon: React__default.ReactNode, color: ButtonProps$1['color'], defaultOptions?: ConfirmOptions) => (title: string, description?: string, options?: ConfirmOptions) => Promise<boolean>;
declare const useConfirmDelete: () => (title: string, description?: string, options?: ConfirmOptions) => Promise<boolean>;
declare const useConfirmWarn: () => (title: string, description?: string, options?: ConfirmOptions) => Promise<boolean>;
declare const useConfirmInfo: () => (title: string, description?: string, options?: ConfirmOptions) => Promise<boolean>;
declare const useConfirmSuccess: () => (title: string, description?: string, options?: ConfirmOptions) => Promise<boolean>;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

declare const KapDateTime: typeof DateTime;
type KapDateTimeFormatOptions = DateTimeFormatOptions;
interface DateDisplayProps {
    date?: Date | number | string;
    format?: DateTimeFormatOptions;
    /**
     * If timeDiffRelative is set, it controls when the date is displayed as relative. Defaults to 1
     * day.
     */
    timeDiffRelative?: number;
    /**
     * Options that is passed to `luxon/toRelative`
     * (https://moment.github.io/luxon/api-docs/index.html#datetimetorelative)
     * Note: These options are not used if `increaseRelativePrecision` is set to true.
     */
    relativeOptions?: ToRelativeOptions;
    /**
     * If true, the date will be displayed as relative. Defaults to true.
     */
    allowRelative?: boolean;
    /**
     * Increase the precision of relative dates. If true, the relative date will be displayed as
     * e.g. "in 1 hour, 15 minutes" instead of "in 1 hour".
     */
    increaseRelativePrecision?: boolean;
    /**
     * A tooltip is shown as default when hovering over a relative date. By setting this to true you
     * get a tooltip regardless if the date is relative or not.
     */
    showTooltip?: boolean;
    /**
     * Tooltip placement. Defaults to "top".
     */
    tooltipPlacement?: TooltipProps['placement'];
    /**
     * The date format used in the tooltip. Defaults to `DateTime.DATETIME_SHORT`
     */
    tooltipDateFormat?: DateTimeFormatOptions;
}
declare const toDateText: (props: DateDisplayProps | Date | number) => string | null;
declare const toDateTextInner: (props: DateDisplayProps) => {
    relative: boolean;
    text: string;
};
declare const DateDisplay: (props: DateDisplayProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

/**
 * Convert a duration in milliseconds to a human readable format
 * @example toTimeDuration(0, 1000) // 1s
 * @example toTimeDuration(0, 86401000) // 1d, 1s
 */
declare const toTimeDuration: (from: number, to: number) => string;
type TimeDurationProps = ({
    from: number;
    to: number;
} | {
    duration: number;
}) & BoxProps;
/**
 * Convert a duration in milliseconds to a human readable format
 */
declare const TimeDuration: (props: TimeDurationProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface FormatMonetaryValueOptions extends Intl.NumberFormatOptions {
    /**
     * The locale to use. If undefined, the browser's locale is used.
     */
    locale?: string;
}
declare const formatMonetaryValue: (value: number, currency: string, options?: FormatMonetaryValueOptions) => string;
interface MonetaryValueProps extends ComponentProps<'span'> {
    value: number;
    currency: string;
    options?: FormatMonetaryValueOptions;
}
declare const MonetaryValue: (props: MonetaryValueProps) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type KapDialogProps<OnCloseFn extends (...args: any[]) => any> = Omit<DialogProps, 'onClose'> & {
    onClose?: OnCloseFn;
};
type KapDialogTitleProps = DialogTitleProps;
type KapDialogContentProps = DialogContentProps;
type KapDialogActionsProps = DialogActionsProps;
declare const KapDialog: {
    <OnCloseFn extends (...args: any[]) => any>(props: KapDialogProps<OnCloseFn>): React__default.JSX.Element;
    Title({ sx, children, ...props }: KapDialogTitleProps): React__default.JSX.Element;
    Content({ sx, ...props }: KapDialogContentProps): React__default.JSX.Element;
    Actions({ sx, ...props }: KapDialogActionsProps): React__default.JSX.Element;
};

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type KapFormDialogProps<OnCloseFn extends (...args: any[]) => any, TFormData = any> = PropsWithChildren<{
    open: KapDialogProps<OnCloseFn>['open'];
    onClose: OnCloseFn;
    title?: ReactNode;
    actions?: ReactNode;
}> & Omit<FormContainerProps<TFormData>, 'children'>;
declare const KapFormDialog: <OnCloseFn extends (...args: any[]) => any>({ open, onClose, title, children, actions, ...formContainerProps }: KapFormDialogProps<OnCloseFn, any>) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

type KapSimpleDialogProps<OnCloseFn extends (...args: any[]) => any> = PropsWithChildren<{
    open: KapDialogProps<OnCloseFn>['open'];
    onClose: (...args: any[]) => any;
    title?: ReactNode;
    actions?: ReactNode;
}>;
declare const KapSimpleDialog: <OnCloseFn extends (...args: any[]) => any>({ open, onClose, title, children, actions, }: KapSimpleDialogProps<OnCloseFn>) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface PieChartIconProps extends SvgIconProps$1 {
    /**
     * The value for the pie slice, between 0 and 100.
     * @example
     * value: 25 // The pie slice will start at 12 o'clock and end at 3 o'clock
     */
    value: number;
    /**
     * Whether to animate the pie chart with a pulsating animation. Useful for e.g. indicating that
     * the value is close to 0 or 100. Defaults to false.
     */
    pulsate?: boolean;
    /**
     * The speed of the pulsating animation. Defaults to 1500 (ms)
     */
    pulsateSpeed?: number;
    /**
     * Inverts the colors of the pie slice. If set to false the pie slice has the same color as the
     * border of the pie chart. If set to true the pie slice has the same color as the background.
     * Defaults to false.
     */
    inverted?: boolean;
}
declare const PieChartIcon: React__default.ForwardRefExoticComponent<Omit<PieChartIconProps, "ref"> & React__default.RefAttributes<SVGSVGElement>>;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface Props {
    content: string;
}
declare const Markdown: (props: Props) => React__default.JSX.Element;

/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: MIT
 */

interface UseUserAgentReturn {
    ua: string;
    os: UAParser.IOS;
    browser: UAParser.IBrowser;
    cpu: UAParser.ICPU;
    device: UAParser.IDevice;
    engine: UAParser.IEngine;
}
/**
 * Generates a user agent object based on the provided user agent string or the user agent string of
 * the current window.
 *
 * @param {string} uastring - The user agent string to parse. If not provided, the user agent string
 * of the current window will be used.
 * @return {UseUserAgentReturn | null} The user agent object containing information about the user
 * agent, or null if an error occurred during parsing.
 */
declare const useUserAgent: (uastring?: string) => UseUserAgentReturn | null;

export { ActionType, Actions, Activity, ActivityType, AssetArtifactInfo, AssetCoreDisplay, AssetDisplay, AssetFetcher, AssetInstallButton, AssetInstallStatus, AssetKindIcon, AssetKindIconText, AssetNameInput, AssetRepositoryInfo, AssetSimpleDisplay, AssetSortSelect, AssetStats, AssetType, AssetTypeFilter, AssetTypeFilterProps, AssetTypes, AssetVersionInfo, AssetVersionSelector, AssetVersionSelectorEntry, AsyncValidationContext, AsyncValidatorFunction, AuthProviderIcon, AuthProviderIconProps, AuthScope, AuthScopesField, AuthScopesList, Author, Autocomplete, AutocompleteProps, AvatarEditor, AvatarFileInfo, AvatarResultType, BUILT_IN_TYPES, BlockHandle, BlockHubDetailsPreviewer, BlockInstanceName, BlockLayout, BlockName, BlockStatus, BlockVersion, Blockhub, BlockhubCategory, BlockhubDetails, BlockhubDetailsProps, BlockhubGridContainer, BlockhubGridProps, BlockhubModal, BlockhubMode, BlockhubSidebar, BlockhubStats, BlockhubTile, BlockhubTileActionButton, BlockhubTileActionButtonProps, BlockhubTileProps, Branch, BranchContainer, Button, ButtonShape, ButtonSize, ButtonStyle, ButtonType, CONFIG_FIELD_ANNOTATIONS, CORE_PREFIX, Checkbox, CheckboxProps, ConfigurationEditor, ConfigurationEditorField, ConfigurationEditorProps, ConfirmProvider, CoreTypes, DRAGGING_HANDLE_CSS, DRAGGING_SOURCE_CSS, DSLAnnotation, DSLComment, DSLConverters, DSLDataType, DSLDataTypeProperty, DSLDefaultValue, DSLEditor, DSLEditorProps, DSLEntity, DSLEntityBase, DSLEntityType, DSLEnum, DSLFormEditorProps, DSLLanguageOptions, DSLMethod, DSLOptions, DSLParameter, DSLParser, DSLParserOptions, DSLResult, DSLRichEntity, DSLType, DSLTypeComplex, DSLWriter, DSL_LANGUAGE_ID, DataGrid, DataGridProps, DataGridTheme, DataList, DataListDetails, DataTypeEditor, DataTypeEditorField, DataTypeEditorProps, DateDisplay, DateDisplayProps, DefaultContext, DefaultFormLayout, DefaultFormLayoutProps, Dependency, DependencyKindLabel, DesktopContainer, DesktopContext, Detail, DetailButtons, DetailRow, DetailRowListValue, DetailRowListValueEntry, DetailRowValue, DetailSize, DnDContainer, DnDDrag, DnDDrop, DockerDetails, DonutProgressIcon, DonutProgressIconProps, Draggable, ElementList, EmptyStateBox, EmptyStateBoxProps, EmptyStateIcon, EmptyStateIconName, EmptyStateIconProps, EntityBlockInstance, EntityBlockInstanceResource, EntityEditor, EntityEditorForm, EntityMapper, FieldProps$1 as FieldProps, FormAutocomplete, FormAvatarEditor, FormAvatarEditorField, FormButtons, FormChangeHandler, FormCheckbox, FormContainer, FormContainerProps, FormContext, FormContextType, FormContextWatcher, FormData, FormField, FormFieldController, FormFieldControllerProps, FormFieldHandler, FormFieldProps, FormFieldType, FormInput, FormInputProps, FormRadioGroup, FormReadyHandler, FormSelect, FormStateChangeEvent, FormTextarea, FormatMonetaryValueOptions, InfinityIcon, InfoBox, InstallerService, KapButton, KapButtonProps, KapDateTime, KapDateTimeFormatOptions, KapDialog, KapDialogActionsProps, KapDialogContentProps, KapDialogProps, KapDialogTitleProps, KapFormDialog, KapFormDialogProps, KapSimpleDialog, KapSimpleDialogProps, KeyValue, KeyValueRow, KindIcon, KindIconText, List, ListElement, Loader, LoaderType, Logo, LogoButton, METHOD_ANNOTATIONS, Markdown, MavenDetails, MethodEditor, MethodEditorField, MethodEditorProps, MonetaryValue, MonetaryValueProps, NPMDetails, OTPCode, OTPInput, OTPInputProps, PARAMETER_ANNOTATIONS, PEGLocation, PEGLocationCoord, PEGValidationEntity, Page, PageProps, PieChartIcon, PieChartIconProps, PromoIcon, REST_METHOD_ANNOTATIONS, ResetListener, STRINGABLE_TYPES, SVGAutoSizeText, SVGButtonAdd, SVGButtonDelete, SVGButtonEdit, SVGButtonInspect, SVGButtonWarning, SVGText, SimpleLoader, SoftError, Sorting, StackContainer, StackPage, StackPageInfo, StandardIcons, StatusType, TYPE_INSTANCE, TYPE_INSTANCE_PROVIDER, TabContainer, TabPage, TabPageInfo, TaskGetter, TaskState, TimeDuration, TimeDurationProps, Toast, ToastContainer, ToastType, Tooltip, TooltipProps, Type, UserAvatar, ValidationContext, ValidatorFunction, ValidatorList, ValidatorListUnresolved, Validators, Version, VersionElement, VersionGraph, VersionList, XTerm, XTermStream, YAMLDetails, applyValidation, asDelayed, asyncInterval, asyncTimeout, coreNames, createHexagon, createVerticalScrollShadow, debouncedValidator, escapeSequence, formatMonetaryValue, fromAssetToAssetVersionSelectorEntry, fromAssetsToAssetVersionSelectorEntries, getIdentifier, getInitialsForName, getNameForKind, getShortKind, globalObject, initApplication, isExtensionKind, isPublic, normaliseValidators, renderArtifact, renderDatetime, renderRepository, roundPathCorners, showToasty, toDateText, toDateTextInner, toStandardType, toTimeDuration, useBlock, useConfirm, useConfirmDelete, useConfirmIcon, useConfirmInfo, useConfirmSuccess, useConfirmWarn, useDesktop, useFormContextField, useFormFieldController, useIsFormSubmitAttempted, useUserAgent, useValidation, withDelay, withFormFieldController };
