@eccenca/gui-elements 6.3.0 → 22.0.1

package/dist/types/cmem/ActivityControl/ActivityControlWidget.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="react" />
+import { TestableComponent } from "../../components/interfaces";
+import { ProgressBarProps } from "../../components/ProgressBar/ProgressBar";
+import { SpinnerProps } from "../../components/Spinner/Spinner";
+export interface IActivityControlProps extends TestableComponent {
+    label?: string | JSX.Element;
+    progressBar?: ProgressBarProps;
+    progressSpinner?: SpinnerProps;
+    statusMessage?: string;
+    activityActions?: IActivityAction[];
+    activityContextMenu?: IActivityContextMenu;
+    small?: boolean;
+    border?: boolean;
+    canShrink?: boolean;
+}
+interface IActivityContextMenu extends TestableComponent {
+    tooltip?: string;
+    menuItems: IActivityMenuAction[];
+}
+export interface IActivityAction extends TestableComponent {
+    action: () => any;
+    tooltip?: string;
+    icon: string;
+    disabled?: boolean;
+    hasStateWarning?: boolean;
+}
+export interface IActivityMenuAction extends IActivityAction, TestableComponent {
+    href?: string;
+}
+/** Shows the status of activities and supports actions on these activities. */
+export declare function ActivityControlWidget(props: IActivityControlProps): JSX.Element;
+export {};

package/dist/types/cmem/ActivityControl/ActivityExecutionErrorReportModal.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+interface IProps {
+    title?: string;
+    onDiscard: () => any;
+    report: JSX.Element;
+    downloadButtonValue: string;
+    closeButtonValue: string;
+    fetchErrorReport: () => Promise<string | undefined>;
+}
+/** Shows the execution error report to the user and offers to download the report. */
+export declare const ActivityExecutionErrorReportModal: ({ title, onDiscard, report, downloadButtonValue, closeButtonValue, fetchErrorReport }: IProps) => JSX.Element;
+export {};

package/dist/types/cmem/ActivityControl/SilkActivityControl.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="react" />
+import { TestableComponent } from "../../components/interfaces";
+import { IActivityStatus } from "./ActivityControlTypes";
+import { TimeUnits } from "../DateTimeDisplay/ElapsedDateTimeDisplay";
+interface SilkActivityControlProps extends TestableComponent {
+    label: string;
+    initialStatus?: IActivityStatus;
+    registerForUpdates: (callback: (status: IActivityStatus) => any) => any;
+    unregisterFromUpdates: () => any;
+    showStartAction: boolean;
+    showStopAction: boolean;
+    failureReportAction?: IErrorReportAction;
+    showReloadAction: boolean;
+    viewValueAction?: {
+        tooltip?: string;
+        action: string | (() => any);
+    };
+    executeActivityAction: (action: ActivityAction) => void;
+    translate: (key: ActivityControlTranslationKeys) => string;
+    elapsedTimeOfLastStart?: {
+        prefix?: string;
+        suffix?: string;
+        translate: (unit: TimeUnits) => string;
+    };
+    layoutConfig?: IActivityControlLayoutProps;
+}
+export interface IActivityControlLayoutProps {
+    small?: boolean;
+    border?: boolean;
+    canShrink?: boolean;
+    visualization?: "none" | "progressbar" | "spinner";
+}
+interface IErrorReportAction {
+    title?: string;
+    renderReport: (report: string | IActivityExecutionReport) => JSX.Element;
+    renderMarkdown: boolean;
+    fetchErrorReport: (markdown: boolean) => Promise<string | IActivityExecutionReport | undefined>;
+    allowDownload?: boolean;
+    downloadButtonValue: string;
+    closeButtonValue: string;
+}
+export interface IActivityExecutionReport {
+    errorSummary: string;
+    projectId?: string;
+    taskId?: string;
+    activityId: string;
+    projectLabel?: string;
+    taskLabel?: string;
+    taskDescription?: string;
+    errorMessage?: string;
+    stackTrace?: IStacktrace;
+}
+interface IStacktrace {
+    errorMessage?: String;
+    lines: string[];
+    cause?: IStacktrace;
+}
+export declare type ActivityControlTranslationKeys = "startActivity" | "stopActivity" | "reloadActivity" | "showErrorReport";
+export declare type ActivityAction = "start" | "cancel" | "restart";
+/** Silk activity control. */
+export declare function SilkActivityControl({ label, initialStatus, registerForUpdates, executeActivityAction, showReloadAction, showStartAction, viewValueAction, showStopAction, failureReportAction, unregisterFromUpdates, translate, elapsedTimeOfLastStart, layoutConfig, ...props }: SilkActivityControlProps): JSX.Element;
+export {};

package/dist/types/cmem/ContentBlobToggler/ContentBlobToggler.d.ts

@@ -0,0 +1,34 @@
+import React from "react";
+interface IContentBlobTogglerProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+          space-delimited list of class names
+      */
+    className?: string;
+    /**
+          text label used for toggler when preview is displayed
+      */
+    toggleExtendText: string;
+    /**
+          text label used for toggler when full view is displayed
+      */
+    toggleReduceText: string;
+    /**
+          content that is displayed as preview
+      */
+    previewContent: React.ReactNode;
+    /**
+          content that is displayed as extended full view
+      */
+    fullviewContent: React.ReactNode;
+    /**
+          Show extended full view initially. Default: false
+      */
+    startExtended?: boolean;
+    /**
+          Callback if toggler is necessary. Default: true
+      */
+    enableToggler?: boolean;
+}
+/** Shows a preview with the option to expand to a full view (and back). */
+export declare function ContentBlobToggler({ className, toggleExtendText, toggleReduceText, previewContent, fullviewContent, startExtended, enableToggler, ...otherProps }: IContentBlobTogglerProps): JSX.Element;
+export {};

package/dist/types/cmem/ContentBlobToggler/StringPreviewContentBlobToggler.d.ts

@@ -0,0 +1,42 @@
+import React from "react";
+interface IStringPreviewContentBlobTogglerProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     space-delimited list of class names
+     */
+    className?: string;
+    /**
+     The preview content will be cut to this length if it is too long.
+     */
+    previewMaxLength?: number;
+    /**
+     text label used for toggler when preview is displayed
+     */
+    toggleExtendText: string;
+    /**
+     text label used for toggler when full view is displayed
+     */
+    toggleReduceText: string;
+    /**
+     The content string. If it is smaller than previewMaxLength this will be displayed in full, else fullviewContent will be displayed.
+     */
+    content: string;
+    /**
+     Content that is displayed as extended full view
+     */
+    fullviewContent: React.ReactNode;
+    /**
+     show extended full view initially
+     */
+    startExtended?: boolean;
+    /** If only the first non-empty line should be shown in the preview. This will in addition also be shortened according to previewMaxLength. */
+    firstNonEmptyLineOnly?: boolean;
+    /** If enabled the preview is rendered as markdown. */
+    renderPreviewAsMarkdown?: boolean;
+    /** White-listing of HTML elements that will be rendered when renderPreviewAsMarkdown is enabled. */
+    allowedHtmlElementsInPreview?: string[];
+}
+/** Version of the content toggler for text only content. */
+export declare function StringPreviewContentBlobToggler({ className, previewMaxLength, toggleExtendText, toggleReduceText, content, fullviewContent, startExtended, firstNonEmptyLineOnly, renderPreviewAsMarkdown, allowedHtmlElementsInPreview }: IStringPreviewContentBlobTogglerProps): JSX.Element;
+/** Takes the first non-empty line from a preview string. */
+export declare function firstNonEmptyLine(preview: string): string;
+export {};

package/dist/types/cmem/DateTimeDisplay/ElapsedDateTimeDisplay.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { TestableComponent } from "../../components/interfaces";
+interface IProps extends TestableComponent {
+    dateTime: string | number;
+    prefix?: string;
+    suffix?: string;
+    showDateTimeTooltip?: boolean;
+    translateUnits: (unit: TimeUnits) => string;
+}
+export declare type TimeUnits = "minute" | "minutes" | "hour" | "hours" | "day" | "days";
+export declare const elapsedTimeSegmented: (elapsedTimeInMs: number) => number[];
+export declare const simplifiedElapsedTime: (timeSegments: number[], translateUnits: (unit: TimeUnits) => string) => string;
+/** Displays the elapsed time in a human readable way. */
+export declare const ElapsedDateTimeDisplay: ({ dateTime, prefix, suffix, showDateTimeTooltip, translateUnits, ...otherProps }: IProps) => JSX.Element;
+export {};

package/dist/types/cmem/index.d.ts

@@ -0,0 +1,10 @@
+import { ActivityControlWidget } from "./ActivityControl/ActivityControlWidget";
+import { ActivityExecutionErrorReportModal } from "./ActivityControl/ActivityExecutionErrorReportModal";
+import { ActivityAction, SilkActivityControl, IActivityControlLayoutProps } from "./ActivityControl/SilkActivityControl";
+import { IActivityStatus } from "./ActivityControl/ActivityControlTypes";
+import { ContentBlobToggler } from "./ContentBlobToggler/ContentBlobToggler";
+import { ElapsedDateTimeDisplay, TimeUnits } from "./DateTimeDisplay/ElapsedDateTimeDisplay";
+import { Markdown } from "./markdown/Markdown";
+import { StringPreviewContentBlobToggler, firstNonEmptyLine } from "./ContentBlobToggler/StringPreviewContentBlobToggler";
+export { ActivityControlWidget, ActivityExecutionErrorReportModal, ContentBlobToggler, Markdown, StringPreviewContentBlobToggler, SilkActivityControl, ElapsedDateTimeDisplay, firstNonEmptyLine, };
+export type { IActivityStatus, ActivityAction, IActivityControlLayoutProps, TimeUnits, };

package/dist/types/cmem/markdown/Markdown.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { PluggableList } from "react-markdown/lib/react-markdown";
+interface MarkdownParserProps {
+    children: string;
+    allowHtml?: boolean;
+    removeMarkup?: boolean;
+    allowedElements?: string[];
+    inheritBlock?: boolean;
+    /** Additional reHype plugins to execute.
+     * @see https://github.com/remarkjs/react-markdown#architecture
+     */
+    reHypePlugins?: PluggableList;
+}
+/** Renders a markdown string. */
+export declare const Markdown: ({ children, allowHtml, removeMarkup, inheritBlock, allowedElements, reHypePlugins }: MarkdownParserProps) => JSX.Element;
+export {};

package/dist/types/common/Intent/index.d.ts

@@ -0,0 +1,7 @@
+export declare const Definitions: {
+    [key: string]: string;
+};
+export declare const ClassNames: {
+    [x: string]: string;
+};
+export declare type IntentTypes = typeof Definitions[keyof typeof Definitions];

package/dist/types/common/utils/openInNewTab.d.ts

@@ -0,0 +1,3 @@
+/** Wrapper for an onClick handler on link-like components, i.e. that navigate to a different URL on click.
+ * Opens a link (url) in a new tab when CMD or CTRL key is pressed at click time. */
+export declare const openInNewTab: (event: React.MouseEvent<HTMLElement>, handler?: ((e: React.MouseEvent<HTMLElement>) => void) | undefined, url?: string | undefined) => void;

package/dist/types/components/Accordion/Accordion.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function Accordion({ children, className, align, ...otherProps }: any): JSX.Element;
+export default Accordion;

package/dist/types/components/Accordion/AccordionItem.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+export interface AccordionItemProps extends React.LiHTMLAttributes<HTMLLIElement> {
+    className?: string;
+    children: string | JSX.Element | JSX.Element[];
+    disabled?: boolean;
+    open?: boolean;
+    label: string | JSX.Element;
+    fullWidth?: boolean;
+    condensed?: boolean;
+    noBorder?: boolean;
+    elevated?: boolean;
+    title?: never;
+}
+declare function AccordionItem({ children, label, className, fullWidth, elevated, condensed, noBorder, ...otherProps }: AccordionItemProps): JSX.Element;
+export default AccordionItem;

package/dist/types/components/Application/ApplicationContainer.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface ApplicationContainerProps extends React.HTMLAttributes<HTMLDivElement> {
+    className?: string;
+}
+declare function ApplicationContainer({ children, className, ...otherProps }: ApplicationContainerProps): JSX.Element;
+export default ApplicationContainer;

package/dist/types/components/Application/ApplicationContent.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+interface IApplicationContentProps {
+    children: React.ReactNode;
+    /**
+        addional class name
+    */
+    className?: string;
+    /**
+        is the sidebar navigation currently displayed or not
+    */
+    isApplicationSidebarExpanded?: boolean;
+    /**
+        is the rail version of the sidebar used or not
+    */
+    isApplicationSidebarRail?: boolean;
+    /**
+        native attributes for the <main> HTML element
+    */
+    htmlMainProps?: React.HTMLAttributes<HTMLElement>;
+}
+declare function ApplicationContent({ children, isApplicationSidebarExpanded, isApplicationSidebarRail, htmlMainProps, ...otherPropsShouldOnlyBeUsedForDataAttributes }: IApplicationContentProps): JSX.Element;
+export default ApplicationContent;

package/dist/types/components/Application/ApplicationHeader.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function ApplicationHeader({ children, ...restProps }: any): JSX.Element;
+export default ApplicationHeader;

package/dist/types/components/Application/ApplicationSidebarNavigation.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+interface IApplicationSidebarNavigationProps extends React.HTMLAttributes<HTMLElement> {
+    className?: string;
+    expanded?: boolean;
+    isRail?: boolean;
+    defaultExpanded?: never;
+    isPersistent?: never;
+    isFixedNav?: never;
+    isChildOfHeader?: never;
+}
+declare function ApplicationSidebarNavigation({ children, className, ...otherProps }: IApplicationSidebarNavigationProps): JSX.Element;
+export default ApplicationSidebarNavigation;

package/dist/types/components/Application/ApplicationSidebarToggler.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function ApplicationSidebarToggler({ ...restProps }: any): JSX.Element;
+export default ApplicationSidebarToggler;

package/dist/types/components/Application/ApplicationTitle.d.ts

@@ -0,0 +1,40 @@
+import React from "react";
+declare type SvgDepiction = HTMLElement & SVGElement;
+declare type ImgDepiction = HTMLElement & HTMLImageElement;
+interface IApplicationTitleProps {
+    children: React.ReactNode;
+    /**
+        addional class name
+    */
+    className?: string;
+    /**
+        prefix the application name by extra string, e.g. company name
+    */
+    prefix?: string;
+    /**
+        home link
+    */
+    href?: string;
+    /**
+        application logo, <img>, <svg> or react element
+    */
+    depiction?: ImgDepiction | SvgDepiction | React.ReactNode;
+    /**
+        is the application title visually displayed or not
+    */
+    isNotDisplayed?: boolean;
+    /**
+        if displayed, is the width aligned with displayed sidebar navigation
+    */
+    isAlignedWithSidebar?: boolean;
+    /**
+        is the sidebar navigation currently displayed or not
+    */
+    isApplicationSidebarExpanded: boolean;
+    /**
+        native attributes for the anchor HTML element (<a>)
+    */
+    htmlAProps?: React.AnchorHTMLAttributes<HTMLAnchorElement>;
+}
+declare function ApplicationTitle({ children, className, prefix, href, depiction, isNotDisplayed, isAlignedWithSidebar, isApplicationSidebarExpanded, htmlAProps, ...otherPropsShouldOnlyBeUsedForDataAttributes }: IApplicationTitleProps): JSX.Element;
+export default ApplicationTitle;

package/dist/types/components/Application/ApplicationToolbar.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function ApplicationToolbar({ children, className, ...restProps }: any): JSX.Element;
+export default ApplicationToolbar;

package/dist/types/components/Application/ApplicationToolbarAction.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function ApplicationToolbarAction({ children, className, ...restProps }: any): JSX.Element;
+export default ApplicationToolbarAction;

package/dist/types/components/Application/ApplicationToolbarPanel.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function ApplicationToolbarPanel({ children, className, ...restProps }: any): JSX.Element;
+export default ApplicationToolbarPanel;

package/dist/types/components/Application/ApplicationToolbarSection.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function ApplicationToolbarSection({ children, className, ...restProps }: any): JSX.Element;
+export default ApplicationToolbarSection;

package/dist/types/components/AutocompleteField/AutoCompleteField.d.ts

@@ -0,0 +1,110 @@
+import React from "react";
+import { HTMLInputProps, IInputGroupProps, IPopoverProps } from "@blueprintjs/core";
+declare type SearchFunction<T extends any> = (value: string) => T[];
+declare type AsyncSearchFunction<T extends any> = (value: string) => Promise<T[]>;
+export interface IRenderModifiers {
+    active: boolean;
+    disabled?: boolean;
+    styleWidth: IElementWidth;
+    highlightingEnabled: boolean;
+}
+/**
+ * Parameters for the auto-complete field parameterized by T and U.
+ * @param T is the input data structure/type of the items that can be selected.
+ * @param U is the output data structure/type that is output on changes of the selected item, i.e. it may get converted first
+ *          before onChange is called.
+ */
+export interface IAutoCompleteFieldProps<T extends any, U extends any> {
+    /**
+     * Fired when text is typed into the input field. Returns a list of items of type T.
+     */
+    onSearch: SearchFunction<T> | AsyncSearchFunction<T>;
+    /**
+     * Fired when value selected from input
+     * @param value The value that has been converted with itemValueSelector.
+     * @param e     The event
+     */
+    onChange?(value: U, e?: React.SyntheticEvent<HTMLElement>): any;
+    /**
+     * The initial value for the auto-complete input field
+     */
+    initialValue?: T;
+    /**
+     * Returns the UI representation of the selectable items.
+     * If the return value is a string, a default render component will be displayed with search highlighting.
+     *
+     * @param item  The item that should be displayed as an option in the select list.
+     * @param query The current search query
+     * @param modifiers Modifiers for rendered elements, e.g. active, disabled.
+     * @param handleClick The function that needs to be called when the rendered item gets clicked. Else a selection
+     *                    via mouse is not possible. This only needs to be used when returning a JSX.Element.
+     */
+    itemRenderer(item: T, query: string, modifiers: IRenderModifiers, handleClick: () => any): string | JSX.Element;
+    /** Renders the string that should be displayed in the input field after the item has been selected.
+     */
+    itemValueRenderer(item: T): string;
+    /**
+     * Selects the part from the auto-completion item that is called with the onChange callback.
+     * @param item The selected item that should be converted to the value that onChange is called with.
+     */
+    itemValueSelector(item: T): U;
+    /** The text that should be displayed when no search result has been found and no custom entry can be created. */
+    noResultText: string;
+    /**
+     * Props to spread to the underlying input field. This is BlueprintJs specific. To control this input, use
+     * `query` and `onQueryChange` instead of `inputProps.value` and
+     * `inputProps.onChange`.
+     */
+    inputProps?: IInputGroupProps & HTMLInputProps;
+    /**
+     * Optional props of the BlueprintJs specific popover element.
+     */
+    popoverProps?: Partial<IPopoverProps>;
+    /** Defines if a value can be reset, i.e. a reset icon is shown and the value is set to a specific value.
+     *  When undefined, a value cannot be reset.
+     */
+    reset?: {
+        /** Returns true if the currently set value can be reset, i.e. set to the resetValue. The reset icon is only
+         *  shown if true is returned. */
+        resettableValue(value: T): boolean;
+        /** The value onChange is called with when a reset action is triggered. */
+        resetValue: U;
+        /** The reset button text that is shown on hovering over the reset icon. */
+        resetButtonText: string;
+    };
+    /** If enabled the auto completion component will auto focus. */
+    autoFocus?: boolean;
+    /** Contains methods for new item creation. If undefined no new, custom items can be created. */
+    createNewItem?: {
+        /** Creates a new item from the query. */
+        itemFromQuery: (query: string) => T;
+        /** Renders how the option to newly create an item should look like in the selection list. */
+        itemRenderer: (query: string, modifiers: IRenderModifiers, handleClick: React.MouseEventHandler<HTMLElement>) => JSX.Element | undefined;
+        /** If the new item option will always be shown as the first entry in the suggestion list, else it will be the last entry.
+         * @default false
+         */
+        showNewItemOptionFirst?: boolean;
+    };
+    /** If true the input field will be disabled. */
+    disabled?: boolean;
+    /** The value to which the search query should be reset after the popover closes.
+     *  By default the query is reset to the result of itemValueRenderer(selectedValue).
+     *
+     * @param selectedValue The currently selected value.
+     */
+    resetQueryToValue?(selectedValue: T): string;
+}
+/** Style object to be used in menu option items. */
+export interface IElementWidth {
+    width: string;
+    maxWidth: string;
+}
+/** Auto-complete input widget. */
+export declare function AutoCompleteField<T extends any, U extends any>(props: IAutoCompleteFieldProps<T, U>): JSX.Element;
+export declare namespace AutoCompleteField {
+    var defaultProps: {
+        autoFocus: boolean;
+        disabled: boolean;
+    };
+}
+export {};

package/dist/types/components/Breadcrumb/BreadcrumbItem.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { IBreadcrumbProps as IBlueprintBreadcrumbItemProps } from "@blueprintjs/core";
+export declare type IBreadcrumbItemProps = Omit<IBlueprintBreadcrumbItemProps, "icon" | "iconTitle" | "intent" | "target">;
+declare function BreadcrumbItem({ className, onClick, href, ...otherBlueprintBreadcrumbProps }: IBreadcrumbItemProps): JSX.Element;
+export default BreadcrumbItem;

package/dist/types/components/Breadcrumb/BreadcrumbList.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+import { IBreadcrumbsProps as IBlueprintBreadcrumbsProps } from "@blueprintjs/core";
+import { IBreadcrumbItemProps } from "./BreadcrumbItem";
+declare type ReducedBreadcrumbsProps = Omit<IBlueprintBreadcrumbsProps, "breadcrumbRenderer" | "collapseFrom" | "currentBreadcrumbRenderer" | "minVisibleItems" | "overflowListProps" | "popoverProps">;
+interface IBreadcrumbListProps extends ReducedBreadcrumbsProps {
+    /**
+        list of breadcrumb items to display
+    */
+    items: IBreadcrumbItemProps[];
+    /**
+        click handler used on breadcrumb items
+    */
+    onItemClick?(itemUrl: string, event: object): any;
+    /**
+        native attributes for the unordered HTML list (ul)
+    */
+    htmlUlProps?: React.HTMLAttributes<HTMLUListElement>;
+    /**
+        char that devides breadcrumb items, default: "/" (currently unsupported)
+    */
+    itemDivider?: never;
+}
+declare function BreadcrumbList({ className, onItemClick, htmlUlProps, ...otherBlueprintBreadcrumbsProps }: IBreadcrumbListProps): JSX.Element;
+export default BreadcrumbList;

package/dist/types/components/Button/Button.d.ts

@@ -0,0 +1,58 @@
+import React from "react";
+import { ButtonProps as BlueprintButtonProps, AnchorButtonProps as BlueprintAnchorButtonProps } from "@blueprintjs/core";
+import { TooltipProps } from "./../Tooltip/Tooltip";
+export declare type AnchorOrButtonProps = Omit<BlueprintButtonProps, "elementRef" | "icon" | "rightIcon"> | Omit<BlueprintAnchorButtonProps, "elementRef" | "icon" | "rightIcon">;
+export interface ButtonProps extends React.HTMLAttributes<HTMLElement> {
+    /**
+    * Always use this when the button triggers an affirmative action, e.g. confirm a process.
+    * The button is displayed with primary color scheme.
+    */
+    affirmative?: boolean;
+    /**
+    * Always use this when the button triggers an disruptive action, e.g. delete or remove.
+    * The button is displayed with primary color scheme.
+    */
+    disruptive?: boolean;
+    /**
+    * Use this when a button is important enough to highlight it in a set of other buttons.
+    * The button is displayed with primary color scheme.
+    */
+    elevated?: boolean;
+    /**
+    * The button is displayed with primary color scheme.
+    */
+    hasStatePrimary?: boolean;
+    /**
+    * The button is displayed with success (some type of green) color scheme.
+    */
+    hasStateSuccess?: boolean;
+    /**
+    * The button is displayed with warning (some type of orange) color scheme.
+    */
+    hasStateWarning?: boolean;
+    /**
+    * The button is displayed with danger (some type of red) color scheme.
+    */
+    hasStateDanger?: boolean;
+    /**
+    * takes in either a string of text or a react element to display as a tooltip when the button is hovered.
+    */
+    tooltip?: string | JSX.Element | null;
+    /**
+    * Object with additional properties for the tooltip.
+    */
+    tooltipProperties?: Partial<Omit<TooltipProps, "content" | "children">>;
+    /**
+    * If an URL is set then the button is included as HTML anchor element instead of a button form element.
+    */
+    href?: string;
+    icon?: string | JSX.Element;
+    rightIcon?: string | JSX.Element;
+    target?: string;
+}
+/**
+ * Display a button element to enable user interaction.
+ * It normally should trigger action when clicked.
+ */
+declare function Button({ children, className, affirmative, disruptive, elevated, hasStatePrimary, hasStateSuccess, hasStateWarning, hasStateDanger, icon, rightIcon, tooltip, tooltipProperties, ...restProps }: ButtonProps & AnchorOrButtonProps): JSX.Element;
+export default Button;

package/dist/types/components/Card/Card.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { CardProps as BlueprintCardProps } from "@blueprintjs/core";
+export interface CardProps extends BlueprintCardProps {
+    /**
+     * When set to `true` card is included as simple HTML `div` element.
+     * By default it is a HTML `section`.
+     */
+    isOnlyLayout?: boolean;
+    /**
+     * When set to true, will take the full height of container
+     */
+    fullHeight?: boolean;
+    /**
+     * when set to true will invert the background color and slightly darken
+     */
+    elevated?: boolean;
+}
+/**
+ * Element to separate content sections from each other.
+ * Cards can include other cards but should not.
+ */
+declare function Card({ children, className, elevation, isOnlyLayout, fullHeight, elevated, interactive, ...otherProps }: CardProps): JSX.Element;
+export default Card;

package/dist/types/components/Card/CardActions.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface OverviewItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Set an inverse direction of how the elements are aligned.
+     * Mainly used for cards used as modals (dialogs).
+     */
+    inverseDirection?: boolean;
+}
+/**
+ * Contains a footer with user-interaction elements like buttons for the `Card` element.
+ * Content must be ordered by importance, so the main action comes before other actions.
+ */
+declare function CardActions({ children, className, inverseDirection, ...otherProps }: OverviewItemProps): JSX.Element;
+export default CardActions;

package/dist/types/components/Card/CardActionsAux.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export interface OverviewItemProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+/**
+ * Additional side buttons inside `CardActions`.
+ * Elements are aligned to the other side of the container.
+ */
+declare function CardActionsAux({ children, className, ...otherProps }: OverviewItemProps): JSX.Element;
+export default CardActionsAux;

package/dist/types/components/Card/CardContent.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export interface OverviewItemProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+/**
+ * Holds the card content.
+ * Display scrollbars in case there is not enough space for it.
+ */
+declare function CardContent({ children, className, ...otherProps }: OverviewItemProps): JSX.Element;
+export default CardContent;