pihr-ui-kit 0.0.1

package/dist/types/components/common/reportComponent/index.d.ts

@@ -0,0 +1,27 @@
+import { TFilterConfig, TTabs } from "./utils";
+export interface IReportComponent {
+    tabs?: TTabs[];
+    filterConfig?: TFilterConfig[] | any;
+    isLoadingPdf?: boolean;
+    isLoadingExcel?: boolean;
+    isLoadingTopSheet?: boolean;
+    filterByTextLabel?: string;
+    resetBtnLabel?: string;
+    pdfDownloadBtnLabel?: string;
+    excelDownloadBtnLabel?: string;
+    topSheetDownloadBtnLabel?: string;
+    hidePDFDownloadBtn?: boolean;
+    hideExcelDownloadBtn?: boolean;
+    showTopSheetDownloadBtn?: boolean;
+    handleFilterDataChange?: any;
+    handleResetData?: (defaultValue: any) => void;
+    handlePDFDownloadReport?: any;
+    handleExcelDownloadReport?: any;
+    handleTopSheetDownloadApi?: any;
+    filterData?: any;
+    canSubmit?: boolean;
+    handleFilterData?: (value: any) => void;
+    addMultipleDataInFilterData?: (object: any, clearKey?: boolean) => void;
+    financialYear?: boolean;
+}
+export default function ReportComponent(props: IReportComponent): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/common/reportComponent/utils.d.ts

@@ -0,0 +1,62 @@
+import { ReactNode } from "react";
+type ColSpan = {
+    [key: number]: string;
+};
+export declare const colSpanClasses: ColSpan;
+export type TTabs = {
+    title: string;
+    filterConfig: TFilterConfig[] | {
+        regular: TFilterConfig[];
+        advanced: TFilterConfig[];
+    };
+};
+export type TFilterConfig = {
+    id?: any;
+    label?: string;
+    type: string;
+    queryKey?: string;
+    multiQueryKey?: string[];
+    customNode?: ReactNode;
+    defaultValue?: any;
+    staticData?: unknown[];
+    apiUrl?: string;
+    labelIdentifierKey?: string;
+    valueIdentifierKey?: string;
+    isAsyncSearchable?: boolean;
+    queryParamKey?: string;
+    colSpan?: number;
+    getCustomNode?: (itemObject: any) => any;
+    selectedNodeAsLabel?: boolean;
+    isRequired?: boolean;
+    hasError?: boolean;
+    errorMessage?: string;
+    orientation?: "horizontal" | "vertical";
+    radioOptions?: any[];
+    extra?: any;
+    extraClassName?: string;
+    extraDiv?: any;
+    checkboxOptions?: any[];
+    dependency?: TDependent;
+    showTime?: boolean;
+    placeholder?: string;
+    omitDate?: boolean;
+    labelClassName?: string;
+    customPlaceholder?: string;
+    isMultiple?: boolean;
+    defaultIndex?: number;
+    maxDate?: Date;
+    inputType?: string;
+};
+export type TDependent = {
+    isDependent: boolean;
+    dependentOn: string | [];
+    dependentQueryKey: string | [];
+};
+export declare const checkKeysInObject: (keys: any, obj: any) => any;
+export declare const getIndex: (array: any, key: any, value: any) => any;
+export declare const isArray: (variable: any) => boolean;
+export declare const isObject: (variable: any) => boolean;
+export declare const formatDate: (date: Date | null | undefined, showTime?: boolean) => string;
+export declare const parseDate: (dateString: string, showTime?: boolean) => Date | null;
+export declare function convertMomentToDateFnsFormat(momentFormat: string): string;
+export {};

package/dist/types/components/common/singleAttachmentInput.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+type TProps = {
+    onFileChange: (files: File) => void;
+    maxFileSize?: number;
+    uploadedAttachment?: string;
+    onDeleteAttachment?: () => void;
+    isRequired?: boolean;
+    hasError?: boolean;
+    errorMessage?: string;
+    acceptedFormats?: string[];
+    label?: string;
+    labelClassName?: string;
+    size?: "sm" | "md";
+    file: File | null;
+    viewIcon?: JSX.Element;
+    hasDownloadIcon?: boolean;
+    hasDeleteIcon?: boolean;
+    downloadIconAction?: () => void;
+};
+declare const SingleAttachmentInput: ({ onFileChange, maxFileSize, uploadedAttachment, onDeleteAttachment, isRequired, hasError, errorMessage, acceptedFormats, label, labelClassName, size, file, viewIcon, hasDownloadIcon, hasDeleteIcon, downloadIconAction, }: TProps) => import("react/jsx-runtime").JSX.Element;
+export default SingleAttachmentInput;

package/dist/types/components/common/switch/switch.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+interface SwitchProps {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+}
+declare const Switch: React.FC<SwitchProps>;
+export default Switch;

package/dist/types/components/common/table/asyncTable.d.ts

@@ -0,0 +1,7 @@
+type TProps = {
+    dataSource: any[];
+    columns: any[];
+    isLoading?: boolean;
+};
+export default function AsyncTable({ dataSource, columns, isLoading }: TProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/common/table/cells/bodyCell.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+type TProps = {
+    children: React.ReactNode;
+    className?: string;
+};
+export default function BodyCell({ children, className }: TProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/common/table/cells/headerCell.d.ts

@@ -0,0 +1,7 @@
+type TProps = {
+    textAlign?: "center" | "left" | "right";
+    label: string;
+    className?: string;
+};
+export default function HeaderCell({ label, textAlign, className, }: TProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/common/table/cells/tableColumnBody.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from "react";
+type TProps = {
+    className?: string;
+    children: ReactNode;
+};
+export default function TableColumnBody({ className, children }: TProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/common/table/cells/tableColumnHeader.d.ts

@@ -0,0 +1,7 @@
+type TProps = {
+    className?: string;
+    textAlign?: "center" | "right" | "left";
+    label: string;
+};
+export default function TableColumnHeader({ className, textAlign, label, }: TProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/common/table/simpleTable.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { ColumnDef, OnChangeFn, RowSelectionState } from "@tanstack/react-table";
+interface DataTableProps<TData, TValue> extends React.ComponentPropsWithoutRef<"div"> {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    rowSelection?: RowSelectionState;
+    setRowSelection?: OnChangeFn<RowSelectionState>;
+    thClass?: string;
+    bodyRowClass?: string;
+    cellClass?: string;
+    isLoading?: boolean;
+    onRowClick?: (row: any) => void;
+}
+export declare function SimpleTable<TData, TValue>({ columns, data, rowSelection, setRowSelection, cellClass, bodyRowClass, isLoading, onRowClick, thClass, ...props }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export default SimpleTable;

package/dist/types/components/common/table/vkTable.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+type TProps = {
+    data: {
+        data: any[];
+        pagination: {
+            page_number: number;
+            page_size: number;
+            total_row: number;
+        };
+    };
+    columns: any[];
+    tableStyles?: any;
+    stripped?: boolean;
+    isLoading?: boolean;
+    selectedRows?: any[];
+    onRowSelect?: (selectedRows: any[]) => void;
+    canSelectRow?: boolean;
+    currentPage?: number;
+    onPageChange?: (value: number) => void;
+    currentPageSize?: number;
+    onPageSizeChange?: (value: number) => void;
+};
+declare const VKTable: React.MemoExoticComponent<({ data, columns, tableStyles, stripped, isLoading, selectedRows, onRowSelect, currentPage, onPageChange, currentPageSize, onPageSizeChange, canSelectRow, }: TProps) => import("react/jsx-runtime").JSX.Element>;
+export default VKTable;

package/dist/types/components/common/tooltip/infoTooltip.d.ts

@@ -0,0 +1,6 @@
+type TProps = {
+    content: string;
+    className?: string;
+};
+export default function InfoTooltip({ content, className }: TProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/common/userHelpTips/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+interface Props {
+    tipsData?: {
+        title: string;
+        tips_detail: string;
+    };
+    isLoadingTipsData?: boolean;
+    children?: React.ReactNode;
+}
+declare const UserHelpTips: ({ tipsData, isLoadingTipsData, children }: Props) => import("react/jsx-runtime").JSX.Element;
+export default UserHelpTips;

package/dist/types/components/common/wrapper/index.d.ts

@@ -0,0 +1,3 @@
+import { PropsWithChildren } from "react";
+declare const ContainerWrapper: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export default ContainerWrapper;

package/dist/types/components/dsl/DslTable/DslTable.d.ts

@@ -0,0 +1,4 @@
+import { DslTableDefinition } from "./types";
+export default function DslTable<Row, Args, ApiRecord = Row>({ config, }: {
+    config: DslTableDefinition<Row, Args, ApiRecord>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dsl/DslTable/DslTableLayout.d.ts

@@ -0,0 +1 @@
+export declare function DslTableLayout<Row>(): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dsl/DslTable/components/ActionRenderer.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { ActionDefinition } from "../types";
+import { ModalContextValue } from "../core/context/DslTableContext";
+interface RenderActionParams<Ctx = unknown> {
+    action: ActionDefinition<Ctx>;
+    ctx: Ctx;
+    openModal: ModalContextValue["openModal"];
+}
+export declare const ActionRenderer: <Ctx = unknown>({ action, ctx, openModal, }: RenderActionParams<Ctx>) => string | number | boolean | import("react/jsx-runtime").JSX.Element | Iterable<import("react").ReactNode> | null | undefined;
+export {};

package/dist/types/components/dsl/DslTable/components/DeleteEntityModal.d.ts

@@ -0,0 +1,10 @@
+interface DeleteModalProps {
+    id: number | string;
+    deleteHook: () => [(id: number | string) => any, ...any];
+    successMessage?: string;
+    errorMessage?: string;
+    translationNs?: string[];
+    onClose?: () => void;
+}
+declare const DeleteEntityModal: ({ id, deleteHook, successMessage, errorMessage, translationNs, onClose, }: DeleteModalProps) => import("react/jsx-runtime").JSX.Element;
+export default DeleteEntityModal;

package/dist/types/components/dsl/DslTable/components/ModalManager.d.ts

@@ -0,0 +1 @@
+export declare const ModalManager: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dsl/DslTable/core/context/DslTableContext.d.ts

@@ -0,0 +1,64 @@
+import React from "react";
+import type { SortingState, PaginationState, RowSelectionState } from "@tanstack/react-table";
+import { DslTableConfig, ModalRegistry, DslTableContextType } from "../../types";
+export interface ModalState {
+    modalId: string;
+    props?: Record<string, unknown>;
+}
+export interface QueryState<Row> {
+    rows: Row[];
+    totalCount: number;
+    pageCount?: number;
+    isLoading: boolean;
+    isFetching: boolean;
+    error?: unknown;
+}
+export declare const DslConfigContext: import("use-context-selector").Context<DslTableConfig<unknown, unknown, unknown> | null>;
+export interface SortingContextValue {
+    sorting: SortingState;
+    onSortingChange: (updater: React.SetStateAction<SortingState>) => void;
+}
+export declare const SortingContext: import("use-context-selector").Context<SortingContextValue | null>;
+export interface PaginationContextValue {
+    pagination: PaginationState | undefined;
+    onPaginationChange: (updater: React.SetStateAction<PaginationState | undefined>) => void;
+}
+export declare const PaginationContext: import("use-context-selector").Context<PaginationContextValue | null>;
+export interface RowSelectionContextValue {
+    rowSelection: RowSelectionState;
+    onRowSelectionChange: (updater: React.SetStateAction<RowSelectionState>) => void;
+}
+export declare const RowSelectionContext: import("use-context-selector").Context<RowSelectionContextValue | null>;
+export interface FiltersContextValue {
+    filters: Record<string, unknown>;
+    onFiltersChange: (updater: React.SetStateAction<Record<string, unknown>>) => void;
+}
+export declare const FiltersContext: import("use-context-selector").Context<FiltersContextValue | null>;
+export declare const QueryStateContext: import("use-context-selector").Context<QueryState<unknown> | null>;
+export declare const DslSharedContext: import("use-context-selector").Context<DslTableContextType<unknown> | null>;
+export interface ModalContextValue {
+    modals: ModalState[];
+    modalRegistry: ModalRegistry;
+    openModal: (key: string, props?: Record<string, unknown>) => void;
+    closeModal: (key: string) => void;
+    closeAll: () => void;
+}
+export declare const ModalContext: import("use-context-selector").Context<ModalContextValue | null>;
+export declare const useDslConfig: <Row = unknown, Args = unknown, ApiRecord = Row>() => DslTableConfig<Row, Args, ApiRecord>;
+export declare const useSorting: () => SortingState;
+export declare const useSortingActions: () => (updater: React.SetStateAction<SortingState>) => void;
+export declare const usePagination: () => PaginationState;
+export declare const usePaginationActions: () => (updater: React.SetStateAction<PaginationState | undefined>) => void;
+export declare const useRowSelection: () => RowSelectionState;
+export declare const useRowSelectionActions: () => (updater: React.SetStateAction<RowSelectionState>) => void;
+export declare const useFiltersState: () => Record<string, unknown>;
+export declare const useFiltersActions: () => (updater: React.SetStateAction<Record<string, unknown>>) => void;
+export declare const useQueryState: () => QueryState<unknown>;
+export declare const useDslContext: <Row = unknown, Context = DslTableContextType<Row>>() => NonNullable<Context>;
+export declare const useModals: () => ModalState[];
+export declare const useModalActions: () => {
+    modalRegistry: ModalRegistry | undefined;
+    openModal: (key: string, props?: Record<string, unknown>) => void;
+    closeModal: (key: string) => void;
+    closeAll: () => void;
+};

package/dist/types/components/dsl/DslTable/core/context/DslTableProvider.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { DslTableConfig } from "../../types";
+export declare const DslTableProvider: <Row, Args, ApiRecord = Row>({ dsl, children, }: {
+    dsl: DslTableConfig<Row, Args, ApiRecord>;
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dsl/DslTable/core/utils/configs.d.ts

@@ -0,0 +1,11 @@
+import { DslTableDefinition, DslTableConfig } from "../../types";
+/**
+ * Transforms the raw DSL table definition into a standardized configuration object.
+ * This function serves as the primary entry point for parsing and normalizing the DSL
+ * before it is consumed by the table components.
+ *
+ * @param dsl - The raw table definition object.
+ * @param t - The translation function for localization.
+ * @returns The fully normalized and processed table configuration.
+ */
+export declare function buildConfigFromDef<Row, Args, ApiRecord = Row>(dsl: DslTableDefinition<Row, Args, ApiRecord>, t: (key: string, defaultText?: string) => string): DslTableConfig<Row, Args, ApiRecord>;

package/dist/types/components/dsl/DslTable/core/utils/index.d.ts

@@ -0,0 +1,3 @@
+import { FilterDefinition } from "../../types";
+export declare function getDefaultPayload<Row, Context>(item: FilterDefinition<Row, Context>, value: unknown): unknown;
+export declare function getFiltersPayload<Row, Context>(filters: Record<string, unknown>, items: FilterDefinition<Row, Context>[]): Record<string, unknown>;

package/dist/types/components/dsl/DslTable/factories/ActionFactories.d.ts

@@ -0,0 +1,63 @@
+import { AppButtonVariation } from "@/components/common/appButton";
+import { ModalAction } from "../types";
+import { ReactNode } from "react";
+export interface StandardEditActionConfig<Ctx> {
+    /** The ID of the edit modal in the registry */
+    modalId?: string;
+    /** Function to compute props passed to the edit modal */
+    props?: (ctx: Ctx) => Record<string, any>;
+    /** Function to determine visibility */
+    visible?: (ctx: Ctx) => boolean;
+    /** Function to determine if enabled */
+    enabled?: (ctx: Ctx) => boolean;
+}
+/**
+ * Creates a standard edit action for a table row
+ */
+export declare function createStandardEditAction<Ctx>(config?: StandardEditActionConfig<Ctx>): ModalAction<Ctx>;
+export interface StandardDeleteActionConfig<Ctx> {
+    /** The mutation hook to perform the deletion */
+    apiHook: any;
+    /** The field in the row used as the unique ID for deletion */
+    idKey?: keyof Ctx;
+    /** The ID of the delete modal in the registry */
+    modalId: string;
+    /** The field in the row used as the display name in the confirmation modal */
+    titleKey?: keyof Ctx;
+    /** Custom confirmation message */
+    confirmationMessage?: string;
+    /** Success message after deletion */
+    successMessage?: string;
+    /** Error message if deletion fails */
+    errorMessage?: string;
+    /** Function to determine visibility */
+    visible?: (ctx: Ctx) => boolean;
+    /** Function to determine if enabled */
+    enabled?: (ctx: Ctx) => boolean;
+}
+/**
+ * Creates a standard delete action with a confirmation modal
+ */
+export declare function createStandardDeleteAction<Ctx>(config: StandardDeleteActionConfig<Ctx>): ModalAction<Ctx>;
+export interface StandardCreateActionConfig<Ctx> {
+    /** The ID of the create modal in the registry */
+    modalId: string;
+    /** Optional display label */
+    label?: ReactNode;
+    /** Optional icon */
+    icon?: ReactNode;
+    /** Visual variation */
+    variation?: AppButtonVariation;
+    /** Optional custom action ID */
+    actionId?: string;
+    /** Function to compute props passed to the modal */
+    props?: (ctx: Ctx) => Record<string, any>;
+    /** Function to determine visibility */
+    visible?: (ctx: Ctx) => boolean;
+    /** Function to determine if enabled */
+    enabled?: (ctx: Ctx) => boolean;
+}
+/**
+ * Creates a standard create action for the topbar
+ */
+export declare function createStandardCreateAction<Ctx>(config: StandardCreateActionConfig<Ctx>): ModalAction<Ctx>;

package/dist/types/components/dsl/DslTable/factories/index.d.ts

@@ -0,0 +1 @@
+export * from "./ActionFactories";

package/dist/types/components/dsl/DslTable/features/Table/TableRenderer.d.ts

@@ -0,0 +1 @@
+export declare const TableRenderer: <Row extends Record<string, unknown>>() => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/dsl/DslTable/features/Table/columns/components/ColumnRenderers.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+import { EmployeeColumn, StatusColumn, ColumnDefinition } from "../../../../types/table";
+export type ColumnRendererProps<Row> = {
+    value: any;
+    column: ColumnDefinition<Row>;
+    rowData: Row;
+};
+export declare function ColumnRenderer<Row>({ value, column, rowData, }: ColumnRendererProps<Row>): import("react/jsx-runtime").JSX.Element;
+export declare const DescriptionRenderer: ({ value }: {
+    value: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TextRenderer: ({ value }: {
+    value: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+type TProps = {
+    image_path: string;
+    employee_name: string;
+    employee_description: string;
+};
+export default function EmployeeField({ image_path, employee_name, employee_description, }: TProps): import("react/jsx-runtime").JSX.Element;
+export declare const EmployeeRenderer: <Row>({ column, rowData, }: {
+    column: EmployeeColumn<Row>;
+    rowData: Row;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const StatusRenderer: <Row>({ column, value, rowData, }: {
+    column: StatusColumn<Row>;
+    value: any;
+    rowData: Row;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dsl/DslTable/features/Table/columns/components/RowActionsRenderer.d.ts

@@ -0,0 +1,10 @@
+import { RowActionConfig } from "../../../../types";
+import { ModalContextValue } from "@/components/dsl/DslTable/core/context/DslTableContext";
+export declare function RowActionsRenderer<Ctx>({ row, rowActions, openModal, }: {
+    row: any;
+    rowActions: RowActionConfig<Ctx>;
+    openModal: ModalContextValue["openModal"];
+}): import("react/jsx-runtime").JSX.Element;
+export declare namespace RowActionsRenderer {
+    var displayName: string;
+}

package/dist/types/components/dsl/DslTable/features/Table/columns/components/TableBodyWrapper.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export declare function TableBodyWrapper({ style, className, children, }: {
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dsl/DslTable/features/Table/columns/index.d.ts

@@ -0,0 +1 @@
+export * from "./utils/columnUtils";

package/dist/types/components/dsl/DslTable/features/Table/columns/utils/columnUtils.d.ts

@@ -0,0 +1,46 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { ColumnDefinition, DslTableConfig } from "../../../../types";
+import { ModalContextValue } from "@/components/dsl/DslTable/core/context/DslTableContext";
+/**
+ * This function transforms a column definition into a tanstack column definition that can be used by the table
+ * @param col The column definition to transform
+ * @returns The transformed column definition
+ */
+export declare function transformColumn<Row>(col: ColumnDefinition<Row>): ColumnDef<Row>;
+/**
+ * This function adds attach bulk selection checkbox with first column to the table
+ * @param columns The columns of the table
+ * @param dsl The dsl configuration
+ * @param transformColumnFn The function to transform the column
+ * @param ColumnRendererComp The component to render the column
+ * @returns The columns of the table with the bulk selection column attached
+ */
+export declare function attachSelectionCheckbox<Row>(columns: ColumnDef<Row>[], dsl: DslTableConfig<Row>): ColumnDef<Row>[];
+/**
+ * This function injects a row actions column to the table
+ * @param columns The columns of the table
+ * @param rowActions The row actions configuration
+ * @param openModal The function to open a modal
+ * @param t The translation function
+ * @returns The columns of the table with the row actions column added
+ */
+export declare function attachActionsColumn<Row>(columns: ColumnDef<Row>[], rowActions: any, openModal: ModalContextValue["openModal"], t: (key: string, defaultText: string) => string): ColumnDef<Row>[];
+/**
+ * This function returns a column definition for the row actions column
+ * @param rowActions The row actions configuration
+ * @param openModal The function to open a modal
+ * @param t The translation function
+ * @returns A column definition for the row actions column
+ */
+export declare function getActionsColumn<Row>(rowActions: any, openModal: ModalContextValue["openModal"], t: (key: string, defaultText: string) => string): ColumnDef<Row>;
+/**
+ * This function builds the tanstack table columns for the table
+ * First transform the dsl columns to tanstack columns
+ * Then attach bulk selection checkbox if enabled
+ * Then attach row actions column if enabled
+ * @param dsl The dsl configuration
+ * @param openModal The function to open a modal
+ * @param t The translation function
+ * @returns The columns for the table
+ */
+export declare function buildTableColumns<Row>(dsl: DslTableConfig<Row>, openModal: ModalContextValue["openModal"], t: (key: string, defaultText: string) => string): ColumnDef<Row>[];

package/dist/types/components/dsl/DslTable/features/Topbar/TopbarRenderer.d.ts

@@ -0,0 +1 @@
+export declare const TopbarRenderer: <Row>() => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/dsl/DslTable/features/Topbar/components/filters/FilterItems.d.ts

@@ -0,0 +1,21 @@
+import { CheckboxFilter, DateFilter, DateRangeFilter, InputFilter } from "../../../../types";
+export declare const InputFilterItem: ({ item, value, onChange, }: {
+    item: InputFilter;
+    value: string;
+    onChange: (val: string) => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const DateFilterItem: ({ item, value, onChange, }: {
+    item: DateFilter;
+    value: Date | null;
+    onChange: (val: Date | null) => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const DateRangeFilterItem: ({ item, value, onChange, }: {
+    item: DateRangeFilter;
+    value: [Date | null, Date | null];
+    onChange: (val: [Date | null, Date | null]) => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const CheckboxFilterItem: ({ item, value, onChange, }: {
+    item: CheckboxFilter;
+    value: boolean;
+    onChange: (value: boolean) => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dsl/DslTable/features/Topbar/components/filters/SelectFilterItem.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { SelectFilter } from "../../../../types";
+import { SelectOptionProps } from "@vivakits/react-components";
+type SelectValue = SelectOptionProps | SelectOptionProps[] | null;
+export declare const SelectFilterItem: import("react").MemoExoticComponent<(<Row, Context>({ item, value, onChange, }: {
+    item: SelectFilter<Row, Context>;
+    value: SelectValue;
+    onChange: (val: SelectValue) => void;
+}) => import("react/jsx-runtime").JSX.Element)>;
+export {};

package/dist/types/components/dsl/DslTable/features/Topbar/components/renderers/ActionsRenderer.d.ts

@@ -0,0 +1,7 @@
+import type { TopbarActionsConfig } from "../../../../types";
+import { DslTableContextType } from "../../../../types";
+interface Props<Row, Context extends DslTableContextType<Row>> {
+    config: TopbarActionsConfig<Row, Context>;
+}
+declare const ActionsRenderer: <Row, Context extends DslTableContextType<Row>>({ config, }: Props<Row, Context>) => import("react/jsx-runtime").JSX.Element;
+export default ActionsRenderer;

package/dist/types/components/dsl/DslTable/features/Topbar/components/renderers/BulkActionsRenderer.d.ts

@@ -0,0 +1,7 @@
+import type { BulkActionConfig } from "../../../../types";
+import { DslTableContextType } from "../../../../types";
+interface Props<Row, Context extends DslTableContextType<Row>> {
+    config: BulkActionConfig<Context>;
+}
+declare const _default: <Row, Context extends DslTableContextType<Row>>({ config, }: Props<Row, Context>) => import("react/jsx-runtime").JSX.Element;
+export default _default;

package/dist/types/components/dsl/DslTable/features/Topbar/components/renderers/FiltersRenderer.d.ts

@@ -0,0 +1,7 @@
+import { FiltersConfig } from "../../../../types";
+import { DslTableContextType } from "../../../../types";
+interface Props<Row, Context extends DslTableContextType<Row>> {
+    config: FiltersConfig<Row, Context>;
+}
+export declare const FiltersRenderer: <Row, Context extends DslTableContextType<Row>>({ config, }: Props<Row, Context>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dsl/DslTable/features/Topbar/components/renderers/SearchRenderer.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { SearchConfig } from "../../../../types";
+import { DslTableContextType } from "../../../../types";
+interface Props<Row, Context extends DslTableContextType<Row>> {
+    config: SearchConfig<Row, Context>;
+}
+export declare const SearchRenderer: <Row, Context extends DslTableContextType<Row>>({ config, }: Props<Row, Context>) => import("react/jsx-runtime").JSX.Element;
+interface SearchBoxProps {
+    className?: string;
+    iconClassName?: string;
+    placeholder?: string;
+    value?: any;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+}
+declare const Searchbox: ({ onChange, placeholder, value, className, }: SearchBoxProps) => import("react/jsx-runtime").JSX.Element;
+export default Searchbox;

package/dist/types/components/dsl/DslTable/features/Topbar/hooks/useTopbarLogic.d.ts

@@ -0,0 +1,8 @@
+export declare const useTopbarLogic: <Row = unknown>() => {
+    showSearch: boolean;
+    showFilters: boolean;
+    showBulkActions: boolean;
+    showActions: boolean;
+    topBarConfig: import("../../..").TopbarConfig<Row, import("../../..").DslTableContextType<Row>> | undefined;
+    bulkActionsConfig: import("../../..").BulkActionConfig<import("../../..").DslTableContextType<Row>> | undefined;
+};

package/dist/types/components/dsl/DslTable/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./DslTable";
+export * from "./types";
+export * from "./factories";