@superblocksteam/library 1.99.99-next.2

package/dist-types/lib/user-facing/components/table/table-widget.d.ts

@@ -0,0 +1,148 @@
+import React from "react";
+import { TableManager } from "./table-manager.js";
+import type { InsertRowOptions } from "./constants.js";
+import type { ColumnFilter, ColumnProperties, ReactTableColumnProps, TableWidgetProps } from "./types.js";
+interface TableWidgetState {
+    isSaving: boolean;
+}
+export declare class TableWidget extends React.Component<TableWidgetProps, TableWidgetState> {
+    customEditValidation: Record<string, undefined | string>;
+    customEditMessage: Record<string, undefined | string>;
+    editOptions: Record<string, undefined | string | Array<string | {
+        label: string;
+        value: string;
+    }>>;
+    tableElement: null | HTMLElement;
+    tableScroller?: null | HTMLElement;
+    dropdownValueToLabelMaps: Record<string, Record<string, string>>;
+    totalRowsInserted: number;
+    suppressLoading: boolean;
+    tableManager: TableManager;
+    state: TableWidgetState;
+    currentCellFocus: {
+        row: number;
+        columnId: string;
+    }[];
+    eventListenerController: AbortController | undefined;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    addEventListeners(): void;
+    componentWillUnmount(): void;
+    getDisplayedValueForEditCell: ({ columnId, rawValue, displayedValue, useLabelAsDisplayValue, }: {
+        columnId: string;
+        rawValue: string;
+        displayedValue?: string;
+        useLabelAsDisplayValue?: boolean;
+    }) => string | undefined;
+    previousColumnsString: string;
+    previousColumns: ReactTableColumnProps[];
+    getReactTableColumns(): ReactTableColumnProps[];
+    static transformData: (tableData: Array<Record<string, unknown>>, filteredOrderMap: Array<number>, columns: ReactTableColumnProps[], editOverrides: Record<number, Record<string, {
+        value: unknown;
+        validationErrors?: Array<string>;
+    }>>) => {
+        [key: string]: any;
+    }[];
+    static getParsedComputedValues(value: string | Array<unknown>): unknown[];
+    getEmptyRow: () => {
+        [key: string]: any;
+    };
+    getSelectedRow: (filteredTableData?: Array<Record<string, unknown>>, selectedRowIndex?: number) => {
+        [key: string]: any;
+    };
+    updateDefaultSelectedRow: (filteredTableData: Array<Record<string, unknown>> | undefined) => void;
+    getSelectedRowIndexes: (selectedRowIndices: string) => number[];
+    getComputedSelectedRowIndices: () => number[];
+    getOriginalRowIndex: (index?: number) => number;
+    getCurrentRowIndex: (originalIndex: number) => number;
+    getIsRowEdited: (rowIndex: number, isOriginalIndex?: boolean) => boolean;
+    getIsRowInserted: (rowIndex: number, isOriginalIndex?: boolean) => boolean;
+    getCellBackground: (currentRowIndex: number, columnId: string) => any;
+    getIsLoading: () => boolean;
+    getDropdownOptionsLoading: () => boolean;
+    render(): React.JSX.Element;
+    handleReorderColumn: (columnOrder: string[]) => void;
+    handleColumnSorting: (column: string, asc: boolean) => void;
+    handleResizeColumn: (columnSizeMap: {
+        [key: string]: number;
+    }) => void;
+    handleSearchTable: (searchKey: any) => void;
+    assignTagColors(tableData: Array<Record<string, unknown>>, columns: ReactTableColumnProps[]): void;
+    selectRows: (rows?: "ALL" | "NONE") => void;
+    handleRowSelect: (index: number, shiftKey?: boolean) => void;
+    getRowContext: (idx?: number) => {
+        row: {
+            [key: string]: any;
+        };
+        rowIndex: number | undefined;
+        currentRow: {
+            [key: string]: any;
+        };
+    };
+    handleRowClick: (_rowData: Record<string, unknown>, index: number) => void;
+    updatePageNumber: (pageNo: number) => void;
+    handleNextPageClick: () => void;
+    handlePrevPageClick: () => void;
+    resetSelectedRowIndex: () => void;
+    handleSetColumnFilter: (columnId: string, filter: ColumnFilter) => void;
+    setCurrentCellFocus: (focus: {
+        row: number;
+        columnId: string;
+    }[]) => void;
+    clearCellFocus: () => void;
+    handleClickOutside: () => void;
+    getTopVisibleIndex: () => number;
+    getBottomVisibleIndex: () => number;
+    handlePaste: (event: Event) => void;
+    handleCopy: (event: Event) => void;
+    handleKeyDown: (event: React.KeyboardEvent) => void;
+    handleEditStart: (rowIndex: number, columnId: string, startingValue: string) => void;
+    getCellValue: (originalRowIndex: number, columnId: string, includeEdits?: boolean) => unknown;
+    handleOneClickEdit: (columnProperties: ColumnProperties, row: number, newValue: unknown) => void;
+    handleEditChange: (value: any, dropdownOptions?: Array<{
+        label: string;
+        value: string;
+    }>) => void;
+    debouncedEditChange: import("lodash").DebouncedFunc<(value: any, dropdownOptions?: Array<{
+        label: string;
+        value: string;
+    }>) => void>;
+    onDropdownEdit: (columnId: string, selectedOption: {
+        label: string;
+        value: string;
+    }) => void;
+    onEditStop: (columnProperties: ColumnProperties, currentRowIndex: number, editStopProps: {
+        shouldSave: boolean;
+        value?: any;
+        validationErrors?: Array<string>;
+        overrideEditFocus?: {
+            row: number;
+            columnId: string;
+        };
+        dropdownOption?: {
+            label: string;
+            value: string;
+        };
+    }) => void;
+    handleEditStop: ({ shouldSave, value, validationErrors, overrideEditFocus, dropdownOption, }: {
+        shouldSave: boolean;
+        value?: any;
+        validationErrors?: Array<string>;
+        overrideEditFocus?: {
+            row: number;
+            columnId: string;
+        };
+        dropdownOption?: {
+            label: string;
+            value: string;
+        };
+    }) => void;
+    handleEditCancel: () => void;
+    handleEditSave: () => void;
+    handleRowDeletion: (currentIndices: number[]) => void;
+    getIsRowDeleted: (rowIndex: number, isOriginalIndex?: boolean) => boolean;
+    insertRow: (defaultRow: Record<string, any>, validationErrors: Record<string, string[]>, options?: InsertRowOptions) => number;
+    handleRowInsertion: (options?: InsertRowOptions) => void;
+    getTableScroller: () => HTMLElement | null | undefined;
+}
+export default TableWidget;

package/dist-types/lib/user-facing/components/table/types.d.ts

@@ -0,0 +1,471 @@
+import type { IconPosition } from "../../icons/constants";
+import type { Dim, DimModes } from "@superblocksteam/library-shared";
+import type { TextStyleWithVariant, UserAccessibleTheme, PerCornerBorderRadius, PerSideBorder } from "@superblocksteam/library-shared/types";
+export declare enum PaginationTypes {
+    NONE = "NONE",
+    CLIENT_SIDE = "CLIENT_SIDE",
+    SERVER_SIDE = "SERVER_SIDE"
+}
+export interface TableFilters {
+    byColumn?: {
+        [column: string]: ColumnFilter;
+    };
+}
+export interface ColumnFilter {
+    byValue?: FilterByValue;
+    condition?: Condition;
+}
+interface FilterByValue {
+    excluded?: any[];
+}
+type Condition = Condition0 | Condition1 | Condition2;
+export type ConditionType = Condition["type"];
+export declare enum Condition0Type {
+    all = "all",
+    isEmpty = "isEmpty",
+    isNotEmpty = "isNotEmpty",
+    isTrue = "isTrue",
+    isFalse = "isFalse"
+}
+export declare enum Condition1Type {
+    textIs = "textIs",
+    textContains = "textContains",
+    textDoesNotContain = "textDoesNotContain",
+    textStartsWith = "textStartsWith",
+    textEndsWith = "textEndsWith",
+    isEqualTo = "isEqualTo",
+    isNotEqualTo = "isNotEqualTo",
+    isLessThan = "isLessThan",
+    isLessThanOrEqualTo = "isLessThanOrEqualTo",
+    isGreaterThan = "isGreaterThan",
+    isGreaterThanOrEqualTo = "isGreaterThanOrEqualTo",
+    dateIs = "dateIs",
+    dateIsBefore = "dateIsBefore",
+    dateIsAfter = "dateIsAfter"
+}
+export declare enum Condition2Type {
+    isBetween = "isBetween",
+    dateIsBetween = "dateIsBetween"
+}
+interface Condition0 {
+    type: Condition0Type;
+}
+interface Condition1 {
+    type: Condition1Type;
+    param: any;
+}
+interface Condition2 {
+    type: Condition2Type;
+    param1: any;
+    param2: any;
+}
+export declare const CompactMode: {
+    readonly SHORT: "SHORT";
+    readonly DEFAULT: "DEFAULT";
+    readonly TALL: "TALL";
+    readonly VERY_SHORT: "VERY_SHORT";
+};
+export type CompactMode = (typeof CompactMode)[keyof typeof CompactMode];
+export declare enum CellAlignmentTypes {
+    LEFT = "LEFT",
+    RIGHT = "RIGHT",
+    CENTER = "CENTER"
+}
+export declare enum VerticalAlignmentTypes {
+    TOP = "TOP",
+    BOTTOM = "BOTTOM",
+    CENTER = "CENTER"
+}
+export declare enum TextSizes {
+    HEADING1 = "HEADING1",
+    HEADING2 = "HEADING2",
+    HEADING3 = "HEADING3",
+    PARAGRAPH = "PARAGRAPH",
+    PARAGRAPH2 = "PARAGRAPH2"
+}
+export declare enum EditInputType {
+    Text = "TEXT",
+    Number = "NUMBER",
+    Email = "EMAIL",
+    Dropdown = "DROPDOWN",
+    Checkbox = "CHECKBOX",
+    Date = "DATE"
+}
+export declare enum BooleanStyleFalse {
+    EMPTY = "EMPTY",
+    CLOSE = "CLOSE",
+    MINUS = "MINUS",
+    EMPTY_CHECKBOX = "EMPTY_CHECKBOX"
+}
+export declare enum ImageSize {
+    Fixed = "FIXED",
+    Fit = "FIT",
+    Cover = "COVER",
+    Grow = "GROW"
+}
+export declare enum IconSize {
+    XXS = "extraExtraSmall",
+    XS = "extraSmall",
+    SMALL = "small",
+    MEDIUM = "medium",
+    LARGE = "large",
+    XL = "extraLarge",
+    XXL = "extraExtraLarge",
+    XXXL = "extraExtraExtraLarge"
+}
+export type TableInserts = {
+    insertedRowsById?: Record<number, Record<string, unknown>>;
+    insertedRowIdsByIndex?: Record<number, Array<number>>;
+    insertedRowValidations?: Record<number, Record<string, undefined | string[]>>;
+};
+export type RowContext = {
+    row: undefined | Record<string, unknown>;
+    rowIndex: undefined | number;
+    currentRow: undefined | Record<string, unknown>;
+};
+export type ColumnContext = {
+    value: any;
+    currentRowIndex: number;
+    currentRow: undefined | Record<string, unknown>;
+};
+interface TableFunctions {
+    setSelectedRowData: (data: {
+        selectedRowIndex: number;
+        selectedRow?: Record<string, unknown>;
+        selectedRowIndices?: number[];
+        selectedRows?: Array<Record<string, unknown>>;
+    }, rowContext: RowContext, triggerEventHandlers: boolean) => void;
+    setPageNo: (value: number, rowContext: RowContext, triggerEventHandlers?: boolean) => void;
+    setTableFilters: (columnId: string, filter: ColumnFilter, rowContext: RowContext) => void;
+    setColumnOrder: (value: string[]) => void;
+    setSortedColumn: (value: undefined | TableSortColumn) => void;
+    setColumnSizeMap: (value: {
+        [key: string]: number;
+    }) => void;
+    setSearchText: (value: string, context: RowContext) => void;
+    updateTagColorAssignment: (value: TagsColorAssignment) => void;
+    onRowClicked: (context: RowContext, onComplete?: () => void) => void;
+    selectAllRows: (rowIndices: number[], rows: Array<Record<string, unknown>>, rowContext: RowContext) => void;
+    deselectAllRows: (rowContext: RowContext) => void;
+    setCurrentCellFocus: (focus: undefined | {
+        row: number;
+        columnId: string;
+    }[]) => void;
+    setCurrentEditFocus: (focus: undefined | {
+        row: number;
+        columnId: string;
+    }, editValue?: string) => void;
+    cancelChanges: () => void;
+    saveChanges: (onComplete: () => void) => void;
+    updateProperties: (updates: Record<string, any>) => void;
+    onRowsDeleted: (rowIndices: number[]) => void;
+    onRowInserted: (rowContext: RowContext) => void;
+}
+export declare const ColumnType: {
+    readonly DATE: "date";
+    readonly VIDEO: "video";
+    readonly IMAGE: "image";
+    readonly TEXT: "text";
+    readonly NUMBER: "number";
+    readonly CURRENCY: "currency";
+    readonly PERCENTAGE: "percentage";
+    readonly BOOLEAN: "boolean";
+    readonly TAGS: "tags";
+    readonly BUTTON: "button";
+    readonly EMAIL: "email";
+    readonly LINK: "link";
+};
+export type ColumnType = (typeof ColumnType)[keyof typeof ColumnType];
+export interface TableStyles {
+    cellBackground?: string;
+    textColor?: string;
+    textSize?: TextSize;
+    fontStyle?: string;
+    horizontalAlign?: CellAlignment;
+    verticalAlign?: VerticalAlignment;
+}
+export type Pagination = keyof typeof PaginationTypes;
+type CellAlignment = keyof typeof CellAlignmentTypes;
+type VerticalAlignment = keyof typeof VerticalAlignmentTypes;
+type TextSize = keyof typeof TextSizes;
+export type SingleCellProperties = ColumnPropertiesForEditing & {
+    horizontalAlign?: CellAlignment;
+    verticalAlign?: VerticalAlignment;
+    textSize?: TextSize;
+    fontStyle?: string;
+    textColor?: string;
+    cellTextStyle?: TextStyleWithVariant;
+    cellBackground?: string;
+    buttonBackgroundColor?: string;
+    buttonVariant?: string;
+    buttonLabelColor?: string;
+    buttonLabel?: string;
+    cellIcon?: string;
+    cellIconPosition?: IconPosition;
+    linkUrl?: string;
+    linkLabel?: string;
+    openInNewTab?: boolean;
+    isDisabled?: boolean;
+    displayedValue?: string;
+    textWrap?: boolean;
+    dropdownIcon?: string;
+    imageBorderRadius?: Dim<DimModes>;
+    imageSize?: ImageSize;
+    openImageUrl?: boolean;
+    inputFormat?: string;
+    outputFormat?: string;
+    manageTimezone?: boolean;
+    timezone?: string;
+    displayTimezone?: string;
+};
+interface TableColumnMetaProps {
+    isHidden: boolean;
+    type: string;
+}
+export interface ReactTableColumnProps {
+    id: string;
+    Header: string;
+    accessor: (data: any) => any;
+    width?: number;
+    actualFlexWidth?: number;
+    minWidth: number;
+    draggable: boolean;
+    isHidden?: boolean;
+    isAscOrder?: boolean;
+    metaProperties?: TableColumnMetaProps;
+    isDerived?: boolean;
+    columnProperties: ColumnProperties;
+    Cell: (props: any) => JSX.Element;
+    sticky?: string;
+}
+interface ColumnPropertiesForEditing {
+    manageTimezone?: boolean;
+    timezone?: string;
+    displayTimezone?: string;
+    dropdownOptions?: string;
+    notation?: Intl.NumberFormatOptions["notation"] | "unformatted";
+    currency?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}
+export type TagDisplayConfig = {
+    color: string;
+};
+export type ColumnPropertyFunctionArgs = {
+    onComplete?: () => void;
+    context: ColumnContext | Record<string, unknown>;
+};
+export type ColumnPropertyFunctions = {
+    onClick?: (args: ColumnPropertyFunctionArgs) => void;
+    onDropdownSearchTextChanged?: (args: ColumnPropertyFunctionArgs) => void;
+    onOptionChange?: (args: ColumnPropertyFunctionArgs) => void;
+    onFocusOut?: (args: ColumnPropertyFunctionArgs) => void;
+    onDateSelected?: (args: ColumnPropertyFunctionArgs) => void;
+    onCheckChange?: (args: ColumnPropertyFunctionArgs) => void;
+};
+export interface ColumnProperties extends ColumnEditConfigs, ColumnPropertiesForEditing, ColumnPropertyFunctions {
+    id: string;
+    label: string;
+    columnType: string;
+    headerIcon?: string;
+    headerIconPosition?: IconPosition;
+    isVisible: boolean;
+    index: number;
+    width: number;
+    cellBackground?: string;
+    horizontalAlign?: CellAlignment;
+    verticalAlign?: VerticalAlignment;
+    textSize?: TextSize;
+    fontStyle?: string;
+    textColor?: string;
+    cellProps?: {
+        textStyle: TextStyleWithVariant;
+    };
+    enableFilter?: boolean;
+    enableSort?: boolean;
+    isDerived: boolean;
+    computedValue: string | string[];
+    displayedValue?: string | string[];
+    buttonLabel?: string;
+    buttonStyle?: string;
+    buttonVariant?: string;
+    buttonLabelColor?: string;
+    cellIcon?: string;
+    cellIconPosition?: IconPosition;
+    isDisabled?: boolean;
+    linkUrl?: string;
+    linkLabel?: string;
+    openInNewTab?: boolean;
+    booleanStyleFalse?: BooleanStyleFalse;
+    isEditable?: boolean | string;
+    isFrozen?: boolean;
+    textWrap?: boolean;
+    tagDisplayConfig: Record<string, TagDisplayConfig>;
+    imageSize?: ImageSize;
+    imageBorderRadius?: Dim<DimModes>;
+    openImageUrl?: boolean;
+    outputFormat?: string | string[];
+    inputFormat?: string | string[];
+}
+export type EditProps = ColumnEditConfigs & {
+    handleEditStart: () => void;
+    handleEditChange: (value: any, dropdownOptions?: Array<{
+        label: string;
+        value: string;
+    }>) => void;
+    handleEditStop: (props: {
+        shouldSave: boolean;
+        value?: any;
+        validationErrors?: Array<string>;
+        moveFocus?: "UP" | "DOWN" | "LEFT" | "RIGHT";
+        overrideEditFocus?: {
+            row: number;
+            columnId: string;
+        };
+        dropdownOption?: {
+            label: string;
+            value: string;
+        };
+    }) => void;
+    handleOneClickEdit: (value: any) => void;
+    isEditFocused: boolean;
+    isEdited: boolean;
+    onDropdownSearchTextChanged?: (value: string) => void;
+    onDropdownIconChange?: (iconName: string) => void;
+    currentEditDropdownSearchText?: string;
+    dropdownOptionsLoading?: boolean;
+    validationErrors: Array<string>;
+    currentEditValue: any;
+};
+type ColumnEditConfigs = {
+    editInputType?: string;
+    editCustomValidationRule?: string;
+    editCustomErrorMessage?: string;
+    editMaxLength?: number;
+    editMinLength?: number;
+    editIsRequired?: boolean;
+    editMultiSelect?: boolean;
+    allowClearing?: boolean;
+    editDropdownClientSideFiltering?: boolean;
+    editOptions?: string | Array<string | {
+        label: string;
+        value: string;
+    }>;
+    useLabelAsDisplayValue?: boolean;
+    transformation?: undefined | {
+        label: string;
+        value: string;
+    };
+    editMinDate?: string;
+    editMaxDate?: string;
+    editTwentyFourHourTime?: boolean;
+    defaultValue?: any;
+    isEditableOnInsertion?: boolean;
+    isRequiredOnInsertion?: boolean;
+};
+export type UnknownRow = Record<string, unknown>;
+export type UnknownRows = Array<UnknownRow>;
+export interface TableSortColumn {
+    column: string;
+    asc: boolean;
+}
+export interface TagsColorAssignment {
+    uniqueTagsCount: number;
+    mapping: Record<string, number>;
+}
+export interface TableWidgetProps extends TableFunctions {
+    sourceId: string;
+    widgetName: string;
+    isLoading: boolean;
+    defaultSearchText: string;
+    searchPlaceholder: string;
+    pageSize: number;
+    configuredPageSize?: number;
+    pageType: Pagination;
+    multiRowSelection?: boolean;
+    columnOrder?: string[];
+    columnSizeMap?: {
+        [key: string]: number;
+    };
+    columns: Record<string, ColumnProperties>;
+    sortedColumn?: TableSortColumn;
+    defaultSort?: TableSortColumn;
+    isDownloadable: boolean;
+    isFilterable: boolean;
+    showColumnBorders: boolean;
+    defaultFilters: string;
+    isSearchable: boolean;
+    tableHeader: string;
+    compactMode: CompactMode;
+    enableRowDeletion: boolean;
+    enableRowInsertion: boolean;
+    maxLinesPerRow?: number;
+    cellProps?: {
+        textStyle: TextStyleWithVariant;
+    };
+    headerProps?: {
+        textStyle: TextStyleWithVariant;
+    };
+    columnHeaderProps?: {
+        textStyle: TextStyleWithVariant;
+    };
+    searchProps?: {
+        textStyle?: TextStyleWithVariant;
+        border?: PerSideBorder;
+        borderRadius?: PerCornerBorderRadius;
+        backgroundColor?: string;
+    };
+    selectedRowBackgroundColor?: string;
+    backgroundColor?: string;
+    borderRadius?: PerCornerBorderRadius;
+    tableData: UnknownRows;
+    tableDataWithInserts: UnknownRows;
+    tableDataWithInsertsOrderMap: Array<number>;
+    defaultSelectedRow?: number | number[];
+    canvasScaleFactor: number;
+    tagsColorAssignment?: TagsColorAssignment;
+    theme: UserAccessibleTheme;
+    border: PerSideBorder;
+    disableNudge: (disable: boolean) => void;
+    filteredTableData?: UnknownRows;
+    filteredOrderMap?: Array<number>;
+    editedRows?: {
+        originalRows: UnknownRows;
+        updatedRows: UnknownRows;
+        deletedRows: UnknownRows;
+        insertedRows: UnknownRows;
+    };
+    editedRowIndices?: {
+        deleted?: {
+            absolute: number[];
+            relative: number[];
+        };
+    };
+    allEdits?: UnknownRows;
+    validationErrors?: Array<string>;
+    searchText: string;
+    currentEditDropdownSearchText: string;
+    filters?: TableFilters;
+    hiddenColumns?: string[];
+    columnFreezes?: Record<string, boolean>;
+    selectedRowIndex?: number;
+    selectedRowIndices: number[];
+    selectedRowSchema?: Record<string, unknown>;
+    selectedRows: Record<string, unknown>[];
+    pageNo: number;
+    editOverrides?: Record<number, Record<string, {
+        value: unknown;
+        validationErrors?: string[];
+    }>>;
+    currentEditValue?: any;
+    currentEditFocus?: {
+        row: number;
+        columnId: string;
+    };
+    deletedRowIndices?: Record<number, boolean>;
+    inserts?: TableInserts;
+    updatedRows?: Record<number, Record<string, unknown>>;
+    height?: Dim<DimModes>;
+    width?: Dim<DimModes>;
+}
+export {};

package/dist-types/lib/user-facing/components/table/use-sticky.d.ts

@@ -0,0 +1 @@
+export declare const useSticky: (hooks: any) => void;

package/dist-types/lib/user-facing/components/table/utils.d.ts

@@ -0,0 +1,2 @@
+import { CompactMode } from "./types.js";
+export declare const getCompactMode: (compactMode: unknown) => CompactMode;

package/dist-types/lib/user-facing/components/text/index.d.ts

@@ -0,0 +1,51 @@
+export declare const SbText: import("react").FC<import("../../properties-panel/props-builder.js").ExternalProps<{
+    general: import("../../properties-panel/props-builder.js").Section<Record<string, import("../../properties-panel/props-builder.js").Prop<any, any>> & {
+        text: import("../../properties-panel/props-builder.js").Prop<string, false>;
+        textType: import("../../properties-panel/props-builder.js").Prop<"number" | "time" | "text" | "date" | "currency", true>;
+    }>;
+    appearance: import("../../properties-panel/props-builder.js").Section<Record<string, import("../../properties-panel/props-builder.js").Prop<any, any>> & ({
+        textStyle: import("../../properties-panel/props-builder.js").Prop<import("@superblocksteam/library-shared/types").TextStyleWithVariant, true>;
+        textAlign: import("../../properties-panel/props-builder.js").Prop<import("@superblocksteam/library-shared/props").TextAlign, true>;
+        verticalAlign: import("../../properties-panel/props-builder.js").Prop<import("./props.js").VerticalAlign, true>;
+        wrapText: import("../../properties-panel/props-builder.js").Prop<boolean, true>;
+        animateLoading: import("../../properties-panel/props-builder.js").Prop<boolean, false>;
+        shouldScroll: import("../../properties-panel/props-builder.js").Prop<boolean, false>;
+        icon: import("../../properties-panel/props-builder.js").Prop<string, false>;
+    } & (Omit<{
+        textType: import("../../properties-panel/props-builder.js").Prop<"number" | "time" | "text" | "date" | "currency", false>;
+    }, "textType" | "dateInputFormat" | "dateOutputFormat"> & ({
+        minimumFractionDigits: import("../../properties-panel/props-builder.js").Prop<number, true>;
+        maximumFractionDigits: import("../../properties-panel/props-builder.js").Prop<number, true>;
+        textType: import("../../properties-panel/props-builder.js").Prop<"currency", true>;
+        currency: import("../../properties-panel/props-builder.js").Prop<string, true>;
+        notation: import("../../properties-panel/props-builder.js").Prop<"compact" | "standard" | "scientific" | "engineering" | "unformatted", true>;
+        dateInputFormat?: undefined;
+        dateOutputFormat?: undefined;
+    } | {
+        minimumFractionDigits: import("../../properties-panel/props-builder.js").Prop<number, true>;
+        maximumFractionDigits: import("../../properties-panel/props-builder.js").Prop<number, true>;
+        textType: import("../../properties-panel/props-builder.js").Prop<"number", true>;
+        notation: import("../../properties-panel/props-builder.js").Prop<"compact" | "standard" | "scientific" | "engineering" | "unformatted", true>;
+        dateInputFormat?: undefined;
+        dateOutputFormat?: undefined;
+    } | {
+        textType: import("../../properties-panel/props-builder.js").Prop<"date", true>;
+        dateInputFormat: import("../../properties-panel/props-builder.js").Prop<string, false>;
+        dateOutputFormat: import("../../properties-panel/props-builder.js").Prop<string, false>;
+    })))>;
+    layout: import("../../properties-panel/props-builder.js").Section<Record<string, import("../../properties-panel/props-builder.js").Prop<any, any>> & {
+        maxHeight?: import("../../properties-panel/props-builder.js").Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false> | undefined;
+        minHeight?: import("../../properties-panel/props-builder.js").Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false> | undefined;
+        maxWidth?: import("../../properties-panel/props-builder.js").Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false> | undefined;
+        minWidth?: import("../../properties-panel/props-builder.js").Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false> | undefined;
+        width: import("../../properties-panel/props-builder.js").Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false>;
+        height: import("../../properties-panel/props-builder.js").Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false>;
+    } & {
+        margin: import("../../properties-panel/props-builder.js").Prop<unknown, true>;
+    } & {
+        isVisible: import("../../properties-panel/props-builder.js").Prop<boolean, true>;
+        collapseWhenInvisible: import("../../properties-panel/props-builder.js").Prop<boolean, false>;
+    } & {
+        shouldScroll: import("../../properties-panel/props-builder.js").Prop<boolean, false>;
+    }>;
+}>>;

package/dist-types/lib/user-facing/components/text/long-text-button.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { ButtonProps as AntButtonProps } from "antd/lib/button";
+interface ButtonProps extends AntButtonProps {
+    width?: string;
+    bordered?: boolean;
+}
+export declare const Button: React.MemoExoticComponent<React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLElement>>>;
+export {};