@archbase/components 3.0.0

package/dist/filters/ArchbaseCompositeFilters.types.d.ts

@@ -0,0 +1,303 @@
+import type { ReactNode } from 'react';
+/**
+ * Tipos de dados suportados pelos filtros, alinhado com FieldDataType do ArchbaseDataGrid
+ */
+export type ArchbaseFieldDataType = 'text' | 'integer' | 'float' | 'currency' | 'boolean' | 'date' | 'datetime' | 'time' | 'enum' | 'image' | 'uuid';
+/**
+ * Operadores de filtro suportados
+ */
+export type ArchbaseFilterOperator = 'contains' | 'starts_with' | 'ends_with' | '=' | '!=' | '>' | '<' | '>=' | '<=' | 'is_null' | 'is_not_null' | 'between' | 'date_before' | 'date_after' | 'date_between' | 'in' | 'not_in';
+/**
+ * Valor de filtro (union type para todos os tipos possíveis)
+ */
+export type FilterValue = string | number | boolean | Date | [Date | null, Date | null] | string[];
+/**
+ * Opção para select/enum
+ */
+export interface FilterOption {
+    value: string;
+    label: string;
+}
+/**
+ * Definição de um campo filtrável
+ */
+export interface ArchbaseFilterDefinition {
+    key: string;
+    label: string;
+    type: ArchbaseFieldDataType;
+    operators?: ArchbaseFilterOperator[];
+    defaultOperator?: ArchbaseFilterOperator;
+    placeholder?: string;
+    icon?: ReactNode;
+    options?: FilterOption[];
+    min?: number;
+    max?: number;
+    step?: number;
+    currencySymbol?: string;
+    disabled?: boolean;
+}
+/**
+ * Filtro ativo
+ */
+export interface ArchbaseActiveFilter {
+    id: string;
+    key: string;
+    label: string;
+    type: ArchbaseFieldDataType;
+    operator: ArchbaseFilterOperator;
+    value: FilterValue;
+    displayValue: string;
+    icon?: ReactNode;
+}
+/**
+ * Preset salvo de filtros
+ */
+export interface SavedFilterPreset {
+    id: string;
+    name: string;
+    filters: ArchbaseActiveFilter[];
+    createdAt: number;
+    isFavorite?: boolean;
+}
+/**
+ * Entrada de histórico de filtros
+ */
+export interface FilterHistoryEntry {
+    filters: ArchbaseActiveFilter[];
+    timestamp: number;
+    rsql?: string;
+}
+/**
+ * Quick filter preset
+ */
+export interface QuickFilterPreset {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: ReactNode;
+    filters: Omit<ArchbaseActiveFilter, 'id'>[];
+    isDefault?: boolean;
+}
+/**
+ * Formatos de saída do filtro
+ */
+export type RSQLOutput = 'controlled' | 'uncontrolled';
+/**
+ * Variantes visuais do componente
+ */
+export type FilterVariant = 'default' | 'compact' | 'minimal' | 'bordered';
+/**
+ * Step do input de filtro
+ */
+export type InputStep = 'field' | 'operator' | 'value';
+/**
+ * Estado do input de filtro
+ */
+export interface FilterInputState {
+    step: InputStep;
+    selectedField: ArchbaseFilterDefinition | null;
+    selectedOperator: ArchbaseFilterOperator | null;
+    inputValue: string;
+    isFocused: boolean;
+}
+/**
+ * Config de dropdowns customizados
+ */
+export interface FilterDropdownConfig {
+    field?: React.ComponentType<any>;
+    operator?: React.ComponentType<any>;
+    value?: React.ComponentType<any>;
+}
+/**
+ * Props do componente principal
+ */
+export interface ArchbaseCompositeFiltersProps {
+    filters: ArchbaseFilterDefinition[];
+    value?: ArchbaseActiveFilter[];
+    onChange?: (filters: ArchbaseActiveFilter[], rsql?: string) => void;
+    rsqlOutput?: RSQLOutput;
+    onRSQLChange?: (rsql: string | undefined) => void;
+    placeholder?: string;
+    maxFilters?: number;
+    variant?: FilterVariant;
+    enablePresets?: boolean;
+    enableHistory?: boolean;
+    enableQuickFilters?: boolean;
+    quickFilters?: QuickFilterPreset[];
+    storageKeyPrefix?: string;
+    customRenderPill?: (filter: ArchbaseActiveFilter, onRemove: () => void) => ReactNode;
+    customDropdowns?: Partial<FilterDropdownConfig>;
+    styles?: ArchbaseCompositeFiltersStyles;
+    classNames?: ArchbaseCompositeFiltersClassNames;
+    onFilterAdd?: (filter: ArchbaseActiveFilter) => void;
+    onFilterRemove?: (filterId: string) => void;
+    onFiltersCleared?: () => void;
+}
+/**
+ * Estilos do componente
+ */
+export interface ArchbaseCompositeFiltersStyles {
+    root?: React.CSSProperties;
+    container?: React.CSSProperties;
+    inputWrapper?: React.CSSProperties;
+    input?: React.CSSProperties;
+    pillsContainer?: React.CSSProperties;
+    pill?: React.CSSProperties;
+    rsqlOutput?: React.CSSProperties;
+    actionsButton?: React.CSSProperties;
+    clearButton?: React.CSSProperties;
+}
+/**
+ * Class names do componente
+ */
+export interface ArchbaseCompositeFiltersClassNames {
+    root?: string;
+    container?: string;
+    inputWrapper?: string;
+    input?: string;
+    pillsContainer?: string;
+    pill?: string;
+    rsqlOutput?: string;
+    actionsButton?: string;
+}
+/**
+ * Hook de filtros - opções
+ */
+export interface UseArchbaseFiltersOptions {
+    initialFilters?: ArchbaseActiveFilter[];
+    onFiltersChange?: (filters: ArchbaseActiveFilter[], rsql?: string) => void;
+}
+/**
+ * Hook de filtros - retorno
+ */
+export interface UseArchbaseFiltersReturn {
+    activeFilters: ArchbaseActiveFilter[];
+    rsqlQuery: string | undefined;
+    addFilter: (filter: Omit<ArchbaseActiveFilter, 'id'>) => void;
+    removeFilter: (id: string) => void;
+    clearFilters: () => void;
+    updateFilter: (id: string, updates: Partial<ArchbaseActiveFilter>) => void;
+    setFilters: (filters: ArchbaseActiveFilter[]) => void;
+    toRSQL: () => string | undefined;
+    toApiFormat: () => ApiFilterFormat[];
+    filtersCount: number;
+    hasFilter: (key: string) => boolean;
+    getFilter: (key: string) => ArchbaseActiveFilter | undefined;
+}
+/**
+ * Format de API (semelhante ao mantine-composite-filters)
+ */
+export interface ApiFilterFormat {
+    field: string;
+    operator: ArchbaseFilterOperator;
+    value: FilterValue;
+}
+/**
+ * Hook de presets - opções
+ */
+export interface UseArchbaseFilterPresetsOptions {
+    storageKey?: string;
+    onLoad?: (filters: ArchbaseActiveFilter[]) => void;
+}
+/**
+ * Hook de presets - retorno
+ */
+export interface UseArchbaseFilterPresetsReturn {
+    presets: SavedFilterPreset[];
+    sortedPresets: SavedFilterPreset[];
+    savePreset: (filters: ArchbaseActiveFilter[], name?: string) => SavedFilterPreset | null;
+    loadPreset: (preset: SavedFilterPreset) => void;
+    deletePreset: (presetId: string) => void;
+    updatePreset: (presetId: string, updates: Partial<Omit<SavedFilterPreset, 'id'>>) => void;
+    toggleFavorite: (presetId: string) => void;
+    hasPresets: boolean;
+}
+/**
+ * Hook de histórico - opções
+ */
+export interface UseArchbaseFilterHistoryOptions {
+    storageKey?: string;
+    maxHistory?: number;
+    enabled?: boolean;
+}
+/**
+ * Hook de histórico - retorno
+ */
+export interface UseArchbaseFilterHistoryReturn {
+    history: FilterHistoryEntry[];
+    recentHistory: FilterHistoryEntry[];
+    clearHistory: () => void;
+    removeHistoryItem: (timestamp: number) => void;
+    loadFromHistory: (timestamp: number) => void;
+    hasHistory: boolean;
+}
+/**
+ * Props do FilterPill
+ */
+export interface FilterPillProps {
+    filter: ArchbaseActiveFilter;
+    onRemove: () => void;
+    onOperatorClick?: () => void;
+    onValueClick?: () => void;
+    isHighlighted?: boolean;
+    compact?: boolean;
+    styles?: ArchbaseCompositeFiltersStyles['pill'];
+}
+/**
+ * Props do dropdown de campo
+ */
+export interface FieldDropdownProps {
+    fields: ArchbaseFilterDefinition[];
+    onSelect: (field: ArchbaseFilterDefinition) => void;
+    inputValue: string;
+}
+/**
+ * Props do dropdown de operador
+ */
+export interface OperatorDropdownProps {
+    field: ArchbaseFilterDefinition;
+    onSelect: (operator: ArchbaseFilterOperator) => void;
+}
+/**
+ * Props do dropdown de valor
+ */
+export interface ValueDropdownProps {
+    field: ArchbaseFilterDefinition;
+    operator: ArchbaseFilterOperator;
+    options: FilterOption[];
+    onSelect: (value: string) => void;
+    inputValue: string;
+}
+/**
+ * Props dos painéis (History, Presets, QuickFilters)
+ */
+export interface FilterPanelProps {
+    isOpen: boolean;
+    onClose: () => void;
+}
+export interface FilterHistoryPanelProps extends FilterPanelProps {
+    history: FilterHistoryEntry[];
+    onLoad: (entry: FilterHistoryEntry) => void;
+    onClear: () => void;
+    onRemove: (timestamp: number) => void;
+}
+export interface FilterPresetsPanelProps extends FilterPanelProps {
+    presets: SavedFilterPreset[];
+    onLoad: (preset: SavedFilterPreset) => void;
+    onSave: (name?: string) => void;
+    onDelete: (presetId: string) => void;
+    onToggleFavorite: (presetId: string) => void;
+}
+export interface QuickFiltersPanelProps extends FilterPanelProps {
+    quickFilters: QuickFilterPreset[];
+    onApply: (preset: QuickFilterPreset) => void;
+}
+/**
+ * Hook de quick filters - retorno
+ */
+export interface UseArchbaseQuickFiltersReturn {
+    quickFilters: QuickFilterPreset[];
+    applyQuickFilter: (presetId: string) => void;
+    addQuickFilter: (preset: QuickFilterPreset) => void;
+    removeQuickFilter: (presetId: string) => void;
+}

package/dist/filters/ArchbaseCompositeFilters.utils.d.ts

@@ -0,0 +1,69 @@
+import type { ArchbaseActiveFilter, ArchbaseFilterOperator, FilterValue, ApiFilterFormat } from './ArchbaseCompositeFilters.types';
+/**
+ * Converte um filtro ativo para o formato RSQL
+ *
+ * @param filter - O filtro ativo a converter
+ * @returns Uma string RSQL representando o filtro
+ *
+ * @example
+ * ```ts
+ * const filter: ArchbaseActiveFilter = {
+ *   id: '1',
+ *   key: 'nome',
+ *   label: 'Nome',
+ *   type: 'text',
+ *   operator: 'contains',
+ *   value: 'João',
+ *   displayValue: 'João'
+ * };
+ * const rsql = convertFilterToRSQL(filter); // "nome=like=*João*"
+ * ```
+ */
+export declare function convertFilterToRSQL(filter: ArchbaseActiveFilter): string;
+/**
+ * Converte uma lista de filtros ativos para uma query RSQL completa
+ *
+ * @param filters - Array de filtros ativos
+ * @returns Uma string RSQL com todos os filtros combinados com AND ( ; )
+ *
+ * @example
+ * ```ts
+ * const filters: ArchbaseActiveFilter[] = [
+ *   { id: '1', key: 'nome', label: 'Nome', type: 'text', operator: 'contains', value: 'João', displayValue: 'João' },
+ *   { id: '2', key: 'idade', label: 'Idade', type: 'integer', operator: '>', value: 18, displayValue: '18' }
+ * ];
+ * const rsql = convertToRSQL(filters); // "nome=like=*João*;idade>18"
+ * ```
+ */
+export declare function convertToRSQL(filters: ArchbaseActiveFilter[]): string | undefined;
+/**
+ * Converte um filtro para o formato de API
+ */
+export declare function convertToApiFormat(filter: ArchbaseActiveFilter): ApiFilterFormat;
+/**
+ * Converte uma lista de filtros para o formato de API
+ */
+export declare function convertToApiFormatList(filters: ArchbaseActiveFilter[]): ApiFilterFormat[];
+/**
+ * Obtém o valor de exibição formatado para um filtro
+ */
+export declare function getDisplayValue(value: FilterValue, type: string, operator: ArchbaseFilterOperator, options?: Array<{
+    value: string;
+    label: string;
+}>): string;
+/**
+ * Obtém os operadores disponíveis para um tipo de dado
+ */
+export declare function getOperatorsForType(type: string): ArchbaseFilterOperator[];
+/**
+ * Obtém o operador padrão para um tipo de dado
+ */
+export declare function getDefaultOperatorForType(type: string): ArchbaseFilterOperator;
+/**
+ * Valida se um valor é válido para um operador e tipo
+ */
+export declare function validateFilterValue(value: FilterValue, type: string, operator: ArchbaseFilterOperator): boolean;
+/**
+ * Gera um ID único para um filtro
+ */
+export declare function generateFilterId(): string;

package/dist/filters/components/FilterPill.d.ts

@@ -0,0 +1,5 @@
+import type { FilterPillProps } from '../ArchbaseCompositeFilters.types';
+/**
+ * Componente que exibe um filtro ativo como uma pill removível
+ */
+export declare function FilterPill({ filter, onRemove, onOperatorClick, onValueClick, isHighlighted, compact, styles, }: FilterPillProps): import("react/jsx-runtime").JSX.Element;

package/dist/filters/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export { useArchbaseFilters, useArchbaseFiltersControlled } from './useArchbaseFilters';
+export { useArchbaseFilterPresets } from './useArchbaseFilterPresets';
+export { useArchbaseFilterHistory } from './useArchbaseFilterHistory';
+export { useArchbaseQuickFilters } from './useArchbaseQuickFilters';

package/dist/filters/hooks/useArchbaseFilterHistory.d.ts

@@ -0,0 +1,24 @@
+import type { ArchbaseActiveFilter, UseArchbaseFilterHistoryOptions, UseArchbaseFilterHistoryReturn } from '../ArchbaseCompositeFilters.types';
+/**
+ * Hook para gerenciar histórico de filtros aplicados
+ *
+ * @param activeFilters - Filtros atuais ativos
+ * @param options - Opções de configuração
+ * @returns Objeto com histórico e ações para gerenciá-lo
+ *
+ * @example
+ * ```ts
+ * const {
+ *   history,
+ *   recentHistory,
+ *   loadFromHistory,
+ *   clearHistory,
+ *   removeHistoryItem,
+ *   hasHistory
+ * } = useArchbaseFilterHistory(activeFilters, {
+ *   storageKey: 'my-app-filter-history',
+ *   maxHistory: 20
+ * });
+ * ```
+ */
+export declare function useArchbaseFilterHistory(activeFilters: ArchbaseActiveFilter[], options?: UseArchbaseFilterHistoryOptions): UseArchbaseFilterHistoryReturn;

package/dist/filters/hooks/useArchbaseFilterPresets.d.ts

@@ -0,0 +1,23 @@
+import type { UseArchbaseFilterPresetsOptions, UseArchbaseFilterPresetsReturn } from '../ArchbaseCompositeFilters.types';
+/**
+ * Hook para gerenciar presets de filtros salvos no localStorage
+ *
+ * @param options - Opções de configuração
+ * @returns Objeto com presets e ações para gerenciá-los
+ *
+ * @example
+ * ```ts
+ * const {
+ *   presets,
+ *   sortedPresets,
+ *   savePreset,
+ *   loadPreset,
+ *   deletePreset,
+ *   toggleFavorite
+ * } = useArchbaseFilterPresets({
+ *   storageKey: 'my-app-filters',
+ *   onLoad: (filters) => console.log('Loaded', filters)
+ * });
+ * ```
+ */
+export declare function useArchbaseFilterPresets(options?: UseArchbaseFilterPresetsOptions): UseArchbaseFilterPresetsReturn;

package/dist/filters/hooks/useArchbaseFilters.d.ts

@@ -0,0 +1,32 @@
+import type { ArchbaseActiveFilter, ArchbaseFilterDefinition, UseArchbaseFiltersOptions, UseArchbaseFiltersReturn } from '../ArchbaseCompositeFilters.types';
+/**
+ * Hook principal para gerenciamento de filtros com conversão RSQL
+ *
+ * @param filterDefinitions - Definições dos campos filtráveis
+ * @param options - Opções de configuração
+ * @returns Objeto com estado e ações para gerenciar filtros
+ *
+ * @example
+ * ```ts
+ * const filters: ArchbaseFilterDefinition[] = [
+ *   { key: 'nome', label: 'Nome', type: 'text' },
+ *   { key: 'idade', label: 'Idade', type: 'integer' }
+ * ];
+ *
+ * const {
+ *   activeFilters,
+ *   rsqlQuery,
+ *   addFilter,
+ *   removeFilter,
+ *   clearFilters
+ * } = useArchbaseFilters(filters);
+ * ```
+ */
+export declare function useArchbaseFilters(filterDefinitions: ArchbaseFilterDefinition[], options?: UseArchbaseFiltersOptions): UseArchbaseFiltersReturn;
+/**
+ * Hook simplificado para gerenciamento de filtros com valor controlado
+ */
+export declare function useArchbaseFiltersControlled(filterDefinitions: ArchbaseFilterDefinition[], value: ArchbaseActiveFilter[], onChange: (filters: ArchbaseActiveFilter[], rsql?: string) => void): Omit<UseArchbaseFiltersReturn, 'activeFilters' | 'rsqlQuery'> & {
+    activeFilters: ArchbaseActiveFilter[];
+    rsqlQuery: string | undefined;
+};

package/dist/filters/hooks/useArchbaseQuickFilters.d.ts

@@ -0,0 +1,26 @@
+import type { ArchbaseActiveFilter, QuickFilterPreset, UseArchbaseQuickFiltersReturn } from '../ArchbaseCompositeFilters.types';
+/**
+ * Hook para gerenciar filtros rápidos predefinidos
+ *
+ * @param predefinedFilters - Filtros rápidos predefinidos
+ * @param onApply - Callback quando um filtro rápido é aplicado
+ * @returns Objeto com filtros rápidos e ações
+ *
+ * @example
+ * ```ts
+ * const quickFilters: QuickFilterPreset[] = [
+ *   {
+ *     id: 'active-users',
+ *     name: 'Active Users',
+ *     filters: [
+ *       { key: 'status', label: 'Status', type: 'text', operator: '=', value: 'active', displayValue: 'active' }
+ *     ]
+ *   }
+ * ];
+ *
+ * const { quickFilters, applyQuickFilter } = useArchbaseQuickFilters(quickFilters, (filters) => {
+ *   console.log('Applied:', filters);
+ * });
+ * ```
+ */
+export declare function useArchbaseQuickFilters(predefinedFilters?: QuickFilterPreset[], onApply?: (filters: ArchbaseActiveFilter[]) => void): UseArchbaseQuickFiltersReturn;

package/dist/filters/index.d.ts

@@ -0,0 +1,8 @@
+export { ArchbaseCompositeFilters } from './ArchbaseCompositeFilters';
+export { FilterPill } from './components/FilterPill';
+export { useArchbaseFilters, useArchbaseFiltersControlled, } from './hooks/useArchbaseFilters';
+export { useArchbaseFilterPresets } from './hooks/useArchbaseFilterPresets';
+export { useArchbaseFilterHistory } from './hooks/useArchbaseFilterHistory';
+export { useArchbaseQuickFilters } from './hooks/useArchbaseQuickFilters';
+export { convertToRSQL, convertToApiFormatList, getDisplayValue, getOperatorsForType, getDefaultOperatorForType, validateFilterValue, generateFilterId, } from './ArchbaseCompositeFilters.utils';
+export type { ArchbaseFieldDataType, ArchbaseFilterOperator, ArchbaseFilterDefinition, ArchbaseActiveFilter, ArchbaseCompositeFiltersProps, SavedFilterPreset, FilterHistoryEntry, QuickFilterPreset, FilterValue, FilterOption, RSQLOutput, FilterVariant, InputStep, ApiFilterFormat, UseArchbaseFiltersOptions, UseArchbaseFiltersReturn, UseArchbaseFilterPresetsOptions, UseArchbaseFilterPresetsReturn, UseArchbaseFilterHistoryOptions, UseArchbaseFilterHistoryReturn, FilterPillProps, FieldDropdownProps, OperatorDropdownProps, ValueDropdownProps, ArchbaseCompositeFiltersStyles, ArchbaseCompositeFiltersClassNames, } from './ArchbaseCompositeFilters.types';

package/dist/forms/index.d.ts

@@ -0,0 +1,3 @@
+export { Button as ArchbaseButton } from '@mantine/core';
+export { ActionIcon as ArchbaseActionIcon } from '@mantine/core';
+export { Fieldset as ArchbaseFieldset } from '@mantine/core';

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { useArchbaseListContext } from './useArchbaseListContext';
+export { useArchbaseVisible } from './useArchbaseVisible';
+export { useArchbaseNavigateParams } from './useArchbaseNavigateParams';
+export { useArchbaseContainerDimensions } from './useArchbaseContainerDimensions';
+export { useArchbaseElementSizeArea } from './useArchbaseElementSizeArea';

package/dist/hooks/useArchbaseContainerDimensions.d.ts

@@ -0,0 +1,4 @@
+export declare const useArchbaseContainerDimensions: (myRef: any) => {
+    width: number;
+    height: number;
+};

package/dist/hooks/useArchbaseElementSizeArea.d.ts

@@ -0,0 +1,6 @@
+interface Size {
+    width: number;
+    height: number;
+}
+declare function useArchbaseElementSizeArea<T extends HTMLElement = HTMLDivElement>(): [(node: T | null) => void, Size];
+export { useArchbaseElementSizeArea };

package/dist/hooks/useArchbaseListContext.d.ts

@@ -0,0 +1,2 @@
+import { ArchbaseListContextValue } from "../list";
+export declare function useArchbaseListContext<T, ID>(): ArchbaseListContextValue<T, ID>;

package/dist/hooks/useArchbaseNavigateParams.d.ts

@@ -0,0 +1,3 @@
+import { NavigateOptions } from "react-router";
+import { URLSearchParamsInit } from "react-router-dom";
+export declare const useArchbaseNavigateParams: () => (pathname: string, options?: NavigateOptions, params?: URLSearchParamsInit) => void;

package/dist/hooks/useArchbaseVisible.d.ts

@@ -0,0 +1,2 @@
+import type { MutableRefObject } from 'react';
+export declare const useArchbaseVisible: <T extends Element, V = number>(cb?: (vi: number) => V, option?: Partial<IntersectionObserverInit>) => [MutableRefObject<T | null>, V];

package/dist/image/ArchbaseImage.d.ts

@@ -0,0 +1,33 @@
+import React, { CSSProperties, FocusEventHandler } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseImageProps<T, ID> {
+    /** Fonte de dados onde será atribuido o valor do rating (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do rating na fonte de dados */
+    dataField?: string;
+    /** Indicador se o rating está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o rating é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do rating é obrigatório */
+    required?: boolean;
+    /** Estilo do checkbox */
+    style?: CSSProperties;
+    /** Texto sugestão do rating */
+    placeholder?: string;
+    /** Título do rating */
+    label?: string;
+    /** Descrição do rating */
+    description?: string;
+    /** Último erro ocorrido no rating */
+    error?: string;
+    /** Evento quando o foco sai do rating */
+    onFocusExit?: FocusEventHandler<T> | undefined;
+    /** Evento quando o rating recebe o foco */
+    onFocusEnter?: FocusEventHandler<T> | undefined;
+    /** Evento quando o valor do rating é alterado */
+    onChangeValue?: (value: any, event: any) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+}
+export declare function ArchbaseImage<T, ID>({ dataSource, dataField, disabled, readOnly, ..._props }: ArchbaseImageProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/image/ArchbaseMicrosoftAvatar.d.ts

@@ -0,0 +1,7 @@
+import { AvatarProps } from '@mantine/core';
+export declare const DEFAULT_AVATAR = "data:image/png;base64,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";
+export interface ArchbaseMicrosoftAvatarProps extends AvatarProps {
+    token?: string | null;
+    email?: string | null;
+}
+export declare const ArchbaseMicrosoftAvatar: ({ token, email, ...others }: ArchbaseMicrosoftAvatarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/image/editor/components/BasicFilters/BasicFilter.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { IBasicFilterState } from '../../models/index.models';
+export interface BasicFilterProps {
+    color: string;
+    initialState: IBasicFilterState | undefined | null;
+    changeFilter: Function;
+}
+declare const BasicFilter: React.MemoExoticComponent<({ color, initialState, changeFilter }: BasicFilterProps) => import("react/jsx-runtime").JSX.Element>;
+export default BasicFilter;

package/dist/image/editor/components/CropprWrapper/ArchbaseCropperWrapper.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import './ArchbaseCropper.scss';
+export declare const ArchbaseCropperWrapper: React.MemoExoticComponent<({ src, size, croppUpdate }: {
+    src: string;
+    size: any;
+    croppUpdate: (data: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }) => void;
+}) => import("react/jsx-runtime").JSX.Element>;

package/dist/image/editor/components/EditImage/ArchbaseEditImage.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { IState } from '../../models/index.models';
+import './ArchbaseEditImage.scss';
+export interface ArchbaseEditImageProps {
+    image: string | null | undefined;
+    color: string;
+    initialState: IState;
+    saveUpdates: Function;
+}
+declare const ArchbaseEditImage: React.MemoExoticComponent<({ image, color, initialState, saveUpdates }: ArchbaseEditImageProps) => import("react/jsx-runtime").JSX.Element>;
+export default ArchbaseEditImage;

package/dist/image/editor/components/Input/Input.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface InputProps extends React.InputHTMLAttributes<any> {
+    onInputChangedEnd?: Function;
+    onChangedDelayed?: Function;
+    onChangedValue?: Function;
+    delayMs?: number;
+}
+declare const Input: React.MemoExoticComponent<(props: React.InputHTMLAttributes<any> | InputProps) => import("react/jsx-runtime").JSX.Element>;
+export default Input;

package/dist/image/editor/components/Tab/Tab.d.ts

@@ -0,0 +1,23 @@
+import React, { ReactNode } from "react";
+import './TabsStyles.scss';
+export interface TabContainerProp {
+    children: Array<React.JSX.Element> | React.JSX.Element;
+    activeIndex?: number;
+    backgroundColor?: string;
+    color?: string;
+    indicatorStyle?: 'simple' | 'bottomLine' | 'button';
+    onTabChange?: Function;
+    lazy?: boolean;
+    transitionMs?: number;
+    borderLine?: boolean;
+    fontColor?: string;
+}
+declare const TabContainer: React.MemoExoticComponent<({ activeIndex, children, backgroundColor, color, indicatorStyle, onTabChange, transitionMs, borderLine, fontColor, lazy }: TabContainerProp) => import("react/jsx-runtime").JSX.Element>;
+export declare const TabItem: React.MemoExoticComponent<({ name, children, icon, type, disabled }: {
+    name: string;
+    children: ReactNode;
+    icon?: React.JSX.Element | string | null | undefined;
+    disabled?: boolean;
+    type?: string;
+}) => import("react/jsx-runtime").JSX.Element>;
+export default TabContainer;