@archbase/components 3.0.0

package/dist/datagrid/modals/print-modal.d.ts

@@ -0,0 +1,9 @@
+import { PrintConfig } from './print-data';
+export interface PrintModalProps {
+    opened: boolean;
+    onClose: () => void;
+    onPrint: (config: PrintConfig) => void;
+    columns: any[];
+    defaultConfig?: Partial<PrintConfig>;
+}
+export declare function PrintModal({ opened, onClose, onPrint, columns, defaultConfig }: PrintModalProps): import("react/jsx-runtime").JSX.Element;

package/dist/datagrid/types/grid-props.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Interface para props do modal de exportação
+ */
+export interface ExportModalProps {
+    opened: boolean;
+    onClose: () => void;
+    onExport: (config: any) => void;
+    columns: any[];
+    defaultConfig?: Partial<any>;
+}
+/**
+ * Interface para props do modal de impressão
+ */
+export interface PrintModalProps {
+    opened: boolean;
+    onClose: () => void;
+    onPrint: (config: any) => void;
+    columns: any[];
+    defaultConfig?: Partial<any>;
+}
+/**
+ * Interface para props de paginação
+ */
+export interface PaginationProps {
+    currentPage: number;
+    pageSize: number;
+    totalRecords: number;
+    pageSizeOptions?: number[];
+    onPageChange: (page: number) => void;
+    onPageSizeChange: (pageSize: number) => void;
+    showPageSizeSelector?: boolean;
+    showNavigationButtons?: boolean;
+    showRecordInfo?: boolean;
+    labels: {
+        totalRecords?: string;
+        pageSize?: string;
+        currentPage?: string;
+        of?: string;
+    };
+}
+/**
+ * Interface para props de pesquisa global
+ */
+export interface GlobalSearchInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onClear: () => void;
+}

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

@@ -0,0 +1 @@
+export * from './grid-props';

package/dist/datagrid/utils/formatter.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Função para formatar valor com base no tipo de dados
+ */
+export declare function getFormattedValueByDataType(value: any, dataType: string, appContext: any, maskOptions?: any): string | number | boolean | null;
+/**
+ * Função para formatar valor para exportação
+ */
+export declare function getFormattedValueForExport(value: any, dataType: string, appContext: any, dateFormat?: string): string;
+/**
+ * Formata um valor decimal com número específico de casas decimais
+ */
+export declare function formatDecimal(value: number | string | undefined, decimalPlaces?: number, useThousandSeparator?: boolean): string;
+/**
+ * Formata um valor como moeda
+ */
+export declare function formatCurrency(value: number | string | undefined, currency?: string, locale?: string): string;
+/**
+ * Formata um valor como data
+ */
+export declare function formatDate(value: string | Date | undefined, dateFormat?: string): string;
+/**
+ * Formata um valor como data e hora
+ */
+export declare function formatDateTime(value: string | Date | undefined, dateTimeFormat?: string): string;
+/**
+ * Formata um valor como hora
+ */
+export declare function formatTime(value: string | Date | number | undefined, timeFormat?: string): string;
+/**
+ * Formata um valor booleano
+ */
+export declare function formatBoolean(value: boolean | undefined | null, trueLabel?: string, falseLabel?: string): string;
+/**
+ * Formata um valor enum com base em opções
+ */
+export declare function formatEnum(value: any, options: {
+    value: any;
+    label: string;
+}[]): string;

package/dist/datagrid/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './formatter';

package/dist/debug/index.d.ts

@@ -0,0 +1,4 @@
+export { ArchbaseJsonView } from './jsonview/index';
+export { ArchbaseJsonPathPicker } from './jsonpathpicker';
+export { ArchbaseObjectInspector, ArchbaseDebugInspector } from './objectinspector';
+export type { ArchbaseObjectToInspect } from './objectinspector';

package/dist/debug/jsonpathpicker/ArchbaseJsonPathPicker.d.ts

@@ -0,0 +1,37 @@
+import { Component } from 'react';
+import './ArchbaseJsonPathPicker.css';
+export interface ArchbaseJsonPathPickerOptions {
+    outputCollapsed: boolean;
+    outputWithQuotes: boolean;
+    pathNotation: string;
+    pathQuotesType: string;
+    processKeys: boolean;
+    keyReplaceRegexPattern: string | undefined;
+    keyReplaceRegexFlags: string | undefined;
+    keyReplacementText: string;
+    pickerIcon: string;
+    withoutPicker: boolean;
+}
+export interface ArchbaseJsonPathPickerProps {
+    data: any;
+    onSelect: (path: string) => void;
+    options?: ArchbaseJsonPathPickerOptions;
+}
+export declare class ArchbaseJsonPathPicker extends Component<ArchbaseJsonPathPickerProps> {
+    static defaultProps: {
+        options: ArchbaseJsonPathPickerOptions;
+    };
+    private pickerRef;
+    private destRef;
+    private jsonPathPickerInstance;
+    constructor(props: ArchbaseJsonPathPickerProps);
+    json2jsx: (json: any, options: any) => import("react/jsx-runtime").JSX.Element | "[]" | "{}";
+    handlerEventToggle: (elm: any, event: any) => void;
+    toggleEventListener: (event: any) => void;
+    simulateClickHandler: (elm: any, event: any) => void;
+    simulateClickEventListener: (event: any) => void;
+    pickPathHandler: (elm: any) => void;
+    pickEventListener: (event: any) => void;
+    componentDidMount(): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}

package/dist/debug/jsonpathpicker/index.d.ts

@@ -0,0 +1 @@
+export { ArchbaseJsonPathPicker } from './ArchbaseJsonPathPicker';

package/dist/debug/jsonview/ArchbaseJsonViewDataRenderer.d.ts

@@ -0,0 +1,34 @@
+export interface StyleProps {
+    container: string;
+    basicChildStyle: string;
+    expander: string;
+    label: string;
+    nullValue: string;
+    undefinedValue: string;
+    numberValue: string;
+    stringValue: string;
+    booleanValue: string;
+    otherValue: string;
+    punctuation: string;
+    pointer: string;
+}
+export interface JsonRenderProps<T> {
+    field?: string;
+    value: T;
+    lastElement: boolean;
+    level: number;
+    style: StyleProps;
+    shouldInitiallyExpand: (level: number, value: any, field?: string) => boolean;
+}
+export interface ExpandableRenderProps {
+    field?: string;
+    value: Array<any> | object;
+    data: Array<[string | undefined, any]>;
+    openBracket: string;
+    closeBracket: string;
+    lastElement: boolean;
+    level: number;
+    style: StyleProps;
+    shouldInitiallyExpand: (level: number, value: any, field?: string) => boolean;
+}
+export default function ArchbaseJsonViewDataRender(props: JsonRenderProps<any>): import("react/jsx-runtime").JSX.Element;

package/dist/debug/jsonview/ArchbaseJsonViewDataTypeDetection.d.ts

@@ -0,0 +1,8 @@
+export declare const isBoolean: (data: any) => data is boolean | Boolean;
+export declare const isNumber: (data: any) => data is number | Number;
+export declare const isBigInt: (data: any) => data is bigint | BigInt;
+export declare const isString: (data: any) => data is string | String;
+export declare const isArray: (data: any) => data is any[];
+export declare const isObject: (data: any) => boolean;
+export declare const isNull: (data: any) => boolean;
+export declare const isUndefined: (data: any) => boolean;

package/dist/debug/jsonview/index.d.ts

@@ -0,0 +1,11 @@
+import { StyleProps } from './ArchbaseJsonViewDataRenderer';
+export interface ArchbaseJsonViewProps {
+    data: NonNullable<unknown> | Array<any>;
+    style?: StyleProps;
+    shouldInitiallyExpand?: (level: number, value: any, field?: string) => boolean;
+}
+export declare const defaultStyles: StyleProps;
+export declare const darkStyles: StyleProps;
+export declare const allExpanded: () => boolean;
+export declare const collapseAllNested: (level: number) => boolean;
+export declare const ArchbaseJsonView: ({ data, style, shouldInitiallyExpand, }: ArchbaseJsonViewProps) => import("react/jsx-runtime").JSX.Element;

package/dist/debug/objectinspector/ArchbaseDebugInspector.d.ts

@@ -0,0 +1,23 @@
+export interface ArchbaseDebugInspectorProps {
+    /** Título a ser exibido */
+    title?: string;
+    /** Título a ser exibido*/
+    icon?: string | HTMLImageElement;
+    /** Comando para abrir e fechar o Object Inspector */
+    debugObjectInspectorHotKey?: string;
+    /** Lista de objetos a serem inspecionados */
+    objectsToInspect?: ArchbaseObjectToInspect[];
+    /** Indica se o Object Inspector será visível inicialmente ou não */
+    visible?: boolean;
+    /** Altura inicial do Object Inspector */
+    height?: number;
+    /** Largura inicial do Object Inspector */
+    width?: number;
+}
+export interface ArchbaseObjectToInspect {
+    /**Nome do objeto a ser inspecionado*/
+    name: string;
+    /**Objeto a ser inspecionado*/
+    object: NonNullable<unknown>;
+}
+export declare function ArchbaseDebugInspector({ title, icon, debugObjectInspectorHotKey, objectsToInspect, visible, height, width, }: ArchbaseDebugInspectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/debug/objectinspector/ArchbaseFloatingWindow.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import './ArchbaseFloatingWindow.css';
+export interface ArchbaseFloatingWindowProps {
+    id: string;
+    children?: any;
+    height: number;
+    width: number;
+    top?: number;
+    left?: number;
+    resizable?: boolean;
+    titleBar?: {
+        icon?: string | HTMLImageElement;
+        title?: string;
+        buttons?: {
+            minimize?: boolean;
+            maximize?: boolean;
+            close?: () => void;
+        };
+    };
+    style?: React.CSSProperties;
+    /** Referência para o container que envolve o componente filho */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+}
+export declare const ArchbaseFloatingWindow: React.FC<ArchbaseFloatingWindowProps>;

package/dist/debug/objectinspector/ArchbaseObjectInspector.d.ts

@@ -0,0 +1,6 @@
+export interface ArchbaseObjectInspectorProps {
+    /** Objeto a ser exibido */
+    data: any;
+    expandLevel?: number;
+}
+export declare function ArchbaseObjectInspector({ data, expandLevel }: ArchbaseObjectInspectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/debug/objectinspector/index.d.ts

@@ -0,0 +1,3 @@
+export { ArchbaseDebugInspector } from './ArchbaseDebugInspector';
+export { ArchbaseObjectInspector } from './ArchbaseObjectInspector';
+export type { ArchbaseObjectToInspect } from './ArchbaseDebugInspector';

package/dist/display/index.d.ts

@@ -0,0 +1,4 @@
+export { Text as ArchbaseText } from '@mantine/core';
+export { Title as ArchbaseTitle } from '@mantine/core';
+export { Image as ArchbaseMantineImage } from '@mantine/core';
+export { Badge as ArchbaseBadge } from '@mantine/core';

package/dist/editors/ArchbaseAsyncMultiSelect.d.ts

@@ -0,0 +1,112 @@
+import { FloatingPosition, MantineSize, OptionsFilter, ScrollAreaProps } from '@mantine/core';
+import React, { CSSProperties, ReactNode } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export type OptionsResult<O> = {
+    options: O[];
+    page: number;
+    totalPages: number;
+};
+export interface ArchbaseAsyncMultiSelectProps<T, ID, O> {
+    /** Permite ou não desselecionar um item */
+    allowDeselect?: boolean;
+    /** Indicador se permite limpar o select */
+    clearable?: boolean;
+    /** Fonte de dados onde será atribuido o item selecionado (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o item selecionado na fonte de dados */
+    dataField?: string;
+    /** Tempo de espero antes de realizar a busca */
+    debounceTime?: number;
+    /** Minimo caracteres para busca */
+    minCharsToSearch?: number;
+    /** Indicador se o select está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o select é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Texto explicativo do select */
+    placeholder?: string;
+    /** Título do select */
+    label?: string;
+    /** Descrição do select */
+    description?: string;
+    /** Último erro ocorrido no select */
+    error?: string;
+    /** Permite pesquisar no select */
+    searchable?: boolean;
+    /** Icon a esquerda do select */
+    icon?: ReactNode;
+    /** Largura do icone a esquerda do select */
+    iconWidth?: MantineSize;
+    /** Valor de entrada controlado */
+    value?: any;
+    /** Valor padrão de entrada não controlado */
+    defaultValue?: any;
+    /** Função com base em quais itens no menu suspenso são filtrados */
+    filter?: OptionsFilter;
+    /** Estilo do select */
+    style?: CSSProperties;
+    /** Tamanho do campo */
+    size?: MantineSize;
+    /** Largura do select */
+    width?: number | string | undefined;
+    /** Estado aberto do menu suspenso inicial */
+    initiallyOpened?: boolean;
+    /** Alterar renderizador de item */
+    itemComponent?: React.FC<any>;
+    /** Alterar renderizador de item selecionado */
+    selectedItemComponent?: React.FC<any>;
+    /** Chamado quando o menu suspenso é aberto */
+    onDropdownOpen?(): void;
+    /** Chamado quando o menu suspenso é aberto */
+    onDropdownClose?(): void;
+    /** Limite a quantidade de itens exibidos por vez para seleção pesquisável */
+    limit?: number;
+    /** Rótulo nada encontrado */
+    nothingFound?: React.ReactNode;
+    /** Índice z dropdown */
+    zIndex?: React.CSSProperties['zIndex'];
+    /** Comportamento de posicionamento dropdown */
+    dropdownPosition?: FloatingPosition;
+    /** Evento quando os valores selecionados são alterados */
+    onChangeValues?: (values: O[]) => void;
+    /** Evento quando o foco sai do select */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o select recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Opções de seleção iniciais */
+    initialOptions?: OptionsResult<O>;
+    /** Function que retorna o label de uma opção */
+    getOptionLabel: (option: O) => string;
+    /** Function que retorna o valor de uma opção */
+    getOptionValue: (option: O) => any;
+    /** Function que retorna a imagem de uma opção */
+    getOptionImage?: (option: O) => any | undefined | null;
+    /** Function responsável por retornar uma promessa contendo opções. Usado para buscar dados remotos. */
+    getOptions: (page: number, value: string) => Promise<OptionsResult<O>>;
+    /** Evento quando ocorreu um erro carregando dados através da promessa fornecida por getOptions. */
+    onErrorLoadOptions?: (error: string) => void;
+    /** Indica se o select tem o preenchimento obrigatório */
+    required?: boolean;
+    /** Chamado sempre que o valor da pesquisa muda */
+    onSearchChange?(query: string): void;
+    /** Converte o valor antes de atribuir ao field do registro atual no datasource */
+    converter?: (value: O) => any;
+    /** Function que busca o valor original antes de converter pelo valor de retorno do converter */
+    getConvertedOption?: (value: any) => Promise<O>;
+}
+export declare const SelectItem: ({ image, label, description, values, value, ...others }: {
+    [x: string]: any;
+    image: any;
+    label: any;
+    description: any;
+    values: any;
+    value: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const SelectedItem: ({ item, value, onRemove, label }: {
+    item: any;
+    value: any;
+    onRemove: any;
+    label: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function ArchbaseAsyncMultiSelect<T, ID, O>({ allowDeselect, clearable, dataSource, dataField, disabled, debounceTime, minCharsToSearch, readOnly, placeholder, initialOptions, searchable, label, description, error, icon, iconWidth, required, getOptionLabel, getOptionValue, getOptionImage, getOptions, onFocusEnter, onFocusExit, onChangeValues, value, defaultValue, filter, size, style, width, initiallyOpened, itemComponent: ItemComponent, selectedItemComponent: SelectedItemComponent, onDropdownOpen, onDropdownClose, limit, nothingFound, zIndex, dropdownPosition, onErrorLoadOptions, onSearchChange, converter, getConvertedOption }: ArchbaseAsyncMultiSelectProps<T, ID, O>): import("react/jsx-runtime").JSX.Element;
+export declare const CustomSelectScrollArea: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;

package/dist/editors/ArchbaseAsyncSelect.context.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface ArchbaseAsyncSelectContextValue {
+    /** Function para notificar o select que o dropdown chegou ao final da lista*/
+    handleDropdownScrollEnded?: () => void;
+}
+declare const ArchbaseAsyncSelectContext: React.Context<ArchbaseAsyncSelectContextValue>;
+declare const ArchbaseAsyncSelectProvider: React.Provider<ArchbaseAsyncSelectContextValue>;
+export { ArchbaseAsyncSelectProvider, ArchbaseAsyncSelectContext };

package/dist/editors/ArchbaseAsyncSelect.d.ts

@@ -0,0 +1,102 @@
+/**
+ * ArchbaseAsyncSelect — select assíncrono com dataSource opcional, suporta paginação/scroll e loading.
+ * @status stable
+ */
+import { FloatingPosition, MantineSize, OptionsFilter, ScrollAreaProps } from '@mantine/core';
+import React, { CSSProperties, ReactNode } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export type OptionsResult<O> = {
+    options: O[];
+    page: number;
+    totalPages: number;
+};
+export interface ArchbaseAsyncSelectProps<T, ID, O> {
+    /** Permite ou não desselecionar um item */
+    allowDeselect?: boolean;
+    /** Indicador se permite limpar o select */
+    clearable?: boolean;
+    /** Fonte de dados onde será atribuido o item selecionado (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o item selecionado na fonte de dados */
+    dataField?: string;
+    /** Tempo de espero antes de realizar a busca */
+    debounceTime?: number;
+    /** Minimo caracteres para busca */
+    minCharsToSearch?: number;
+    /** Indicador se o select está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o select é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Texto explicativo do select */
+    placeholder?: string;
+    /** Título do select */
+    label?: string;
+    /** Descrição do select */
+    description?: string;
+    /** Último erro ocorrido no select */
+    error?: string;
+    /** Permite pesquisar no select */
+    searchable?: boolean;
+    /** Icon a esquerda do select */
+    icon?: ReactNode;
+    /** Largura do icone a esquerda do select */
+    iconWidth?: MantineSize;
+    /** Valor de entrada controlado */
+    value?: any;
+    /** Valor padrão de entrada não controlado */
+    defaultValue?: any;
+    /** Função com base em quais itens no menu suspenso são filtrados */
+    filter?: OptionsFilter;
+    /** Estilo do select */
+    style?: CSSProperties;
+    /** Tamanho do campo */
+    size?: MantineSize;
+    /** Largura do select */
+    width?: number | string | undefined;
+    /** Estado aberto do menu suspenso inicial */
+    initiallyOpened?: boolean;
+    /** Alterar renderizador de item */
+    itemComponent?: React.FC<any>;
+    /** Chamado quando o menu suspenso é aberto */
+    onDropdownOpen?(): void;
+    /** Chamado quando o menu suspenso é aberto */
+    onDropdownClose?(): void;
+    /** Limite a quantidade de itens exibidos por vez para seleção pesquisável */
+    limit?: number;
+    /** Rótulo nada encontrado */
+    nothingFound?: React.ReactNode;
+    /** Índice z dropdown */
+    zIndex?: React.CSSProperties['zIndex'];
+    /** Comportamento de posicionamento dropdown */
+    dropdownPosition?: FloatingPosition;
+    /** Evento quando um valor é selecionado */
+    onSelectValue?: (value: O) => void;
+    /** Evento quando o foco sai do select */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o select recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Opções de seleção iniciais */
+    initialOptions?: OptionsResult<O>;
+    /** Function que retorna o label de uma opção */
+    getOptionLabel: (option: O) => string;
+    /** Function que retorna o valor de uma opção */
+    getOptionValue: (option: O) => any;
+    /** Function que retorna a imagem de uma opção */
+    getOptionImage?: (option: O) => any | undefined | null;
+    /** Function responsável por retornar uma promessa contendo opções. Usado para buscar dados remotos. */
+    getOptions: (page: number, value: string) => Promise<OptionsResult<O>>;
+    /** Evento quando ocorreu um erro carregando dados através da promessa fornecida por getOptions. */
+    onErrorLoadOptions?: (error: string) => void;
+    /** Indica se o select tem o preenchimento obrigatório */
+    required?: boolean;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    /** Chamado sempre que o valor da pesquisa muda */
+    onSearchChange?(query: string): void;
+    /** Converte o valor antes de atribuir ao field do registro atual no datasource */
+    converter?: (value: O) => any;
+    /** Function que busca o valor original antes de converter pelo valor de retorno do converter */
+    getConvertedOption?: (value: any) => Promise<O>;
+}
+export declare function ArchbaseAsyncSelect<T, ID, O>({ allowDeselect, clearable, dataSource, dataField, disabled, debounceTime, minCharsToSearch, readOnly, placeholder, initialOptions, searchable, label, description, error, icon, iconWidth, required, getOptionLabel, getOptionValue, getOptionImage, getOptions, onFocusEnter, onFocusExit, onSelectValue, value, defaultValue, filter, size, style, width, initiallyOpened, itemComponent: ItemComponent, onDropdownOpen, onDropdownClose, limit, nothingFound, zIndex, dropdownPosition, onErrorLoadOptions, innerRef, onSearchChange, converter, getConvertedOption }: ArchbaseAsyncSelectProps<T, ID, O>): import("react/jsx-runtime").JSX.Element;
+export declare const CustomSelectScrollArea: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;

package/dist/editors/ArchbaseAvatarEdit.d.ts

@@ -0,0 +1,49 @@
+import { ActionIconVariant } from '@mantine/core';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+import React, { CSSProperties } from 'react';
+export interface ArchbaseAvatarEditProps<T, ID> {
+    /** Fonte de dados onde será atribuido o valor do avatar (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do avatar na fonte de dados */
+    dataField?: string;
+    /** Indicador se o avatar está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o avatar é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do avatar é obrigatório */
+    required?: boolean;
+    /** Estilo do avatar */
+    style?: CSSProperties;
+    /** Título do avatar */
+    label?: string;
+    /** Descrição do avatar */
+    description?: string;
+    /** Último erro ocorrido no avatar */
+    error?: string;
+    /** Controla a aparência dos botões, sendo padrão "transparent". */
+    variant?: ActionIconVariant;
+    /** Image src */
+    src?: string | null;
+    /** Largura do avatar, padrão 200 */
+    width?: number;
+    /** Altura do avatar, padrão 200 */
+    height?: number;
+    /** Zoom inicial do avatar, padrão 1 */
+    initialZoom?: number;
+    /** Chave de theme.radius ou qualquer valor CSS válido para definir border-radius, 0 por padrão */
+    radius?: string | number | undefined;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    /** Callback quando a imagem for alterada */
+    onChangeImage?: (image: any) => void;
+    /** Desabilita conversão do conteúdo em base64 antes de salvar na fonte de dados */
+    disabledBase64Convertion?: boolean;
+    /** Cor de fundo de hover do avatar */
+    hoverBackgroundColor?: string;
+    /** Tamanho máximo da imagem em kilobytes */
+    maxSizeKB?: number;
+    /** Qualidade da compressão da imagem (0 a 1), sendo 1 melhor qualidade */
+    imageQuality?: number;
+}
+export declare function ArchbaseAvatarEdit<T, ID>({ width, height, dataSource, dataField, disabled, readOnly, required, label, description, error, src, radius, initialZoom, onChangeImage, disabledBase64Convertion, innerRef, variant, hoverBackgroundColor, maxSizeKB, // 0 significa sem limite
+imageQuality, ...otherProps }: ArchbaseAvatarEditProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseCheckbox.d.ts

@@ -0,0 +1,45 @@
+import { MantineSize } from '@mantine/core';
+import type { CSSProperties } from 'react';
+import React, { ReactNode } from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseCheckboxProps<T, ID> {
+    /** Fonte de dados onde será atribuido o valor do checkbox (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do checkbox na fonte de dados */
+    dataField?: string;
+    /** Indicador se o checkbox está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o checkbox é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do checkbox é obrigatório */
+    required?: boolean;
+    /** Estilo do checkbox */
+    style?: CSSProperties;
+    /** Chave de theme.radius ou qualquer valor CSS válido para definir border-radius, theme.defaultRadius por padrão */
+    radius?: string | number | undefined;
+    /** Valor quando o checkbox estiver true */
+    trueValue?: any;
+    /** Valor quando o checkbox estiver false */
+    falseValue?: any;
+    /** Indicador se o checkbox está marcado */
+    isChecked?: boolean;
+    /** Título do checkbox */
+    label?: ReactNode;
+    /** Largura do checkbox */
+    width?: string | number | undefined;
+    /** Descrição do checkbox */
+    description?: string;
+    /** Último erro ocorrido no checkbox */
+    error?: string;
+    /** Valor de tamanho predefinido */
+    size?: MantineSize;
+    /** Evento quando o foco sai do checkbox */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o checkbox recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o valor do checkbox é alterado */
+    onChangeValue?: (value: any, event: any) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+}
+export declare function ArchbaseCheckbox<T, ID>({ dataSource, dataField, disabled, readOnly, required, style, trueValue, falseValue, isChecked, width, label, description, error, size, radius, onFocusExit, onFocusEnter, onChangeValue, innerRef, }: ArchbaseCheckboxProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseChip.d.ts

@@ -0,0 +1,43 @@
+import { MantineSize } from '@mantine/core';
+import type { CSSProperties } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseChipProps<T, ID> {
+    /** Fonte de dados onde será atribuido o valor do chip (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do chip na fonte de dados */
+    dataField?: string;
+    /** Indicador se o chip está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o chip é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do chip é obrigatório */
+    required?: boolean;
+    /** Estilo do chip */
+    style?: CSSProperties;
+    /** Chave de theme.radius ou qualquer valor CSS válido para definir border-radius, theme.defaultRadius por padrão */
+    radius?: string | number | undefined;
+    /** Valor quando o chip estiver true */
+    trueValue?: any;
+    /** Valor quando o chip estiver false */
+    falseValue?: any;
+    /** Indicador se o chip está marcado */
+    isChecked?: boolean;
+    /** Título do chip */
+    label?: string;
+    /** Largura do chip */
+    width?: string | number | undefined;
+    /** Valor de tamanho predefinido */
+    size?: MantineSize;
+    /** Evento quando o foco sai do chip */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o chip recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o valor do chip é alterado */
+    onChangeValue?: (value: any) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    /** Último erro ocorrido no chip */
+    error?: string;
+}
+export declare function ArchbaseChip<T, ID>({ dataSource, dataField, disabled, readOnly, required, style, trueValue, falseValue, isChecked, width, label, size, radius, error, onFocusExit, onFocusEnter, onChangeValue, innerRef, }: ArchbaseChipProps<T, ID>): import("react/jsx-runtime").JSX.Element;