@archbase/components 3.0.0

package/dist/editors/ArchbaseChipGroup.d.ts

@@ -0,0 +1,42 @@
+import { ChipVariant } from '@mantine/core';
+import { CSSProperties, ReactNode } from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseChipGroupProps<T, ID, O> {
+    /** Fonte de dados onde será atribuido o valor do ChipGroup (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do ChipGroup na fonte de dados */
+    dataField?: string;
+    /** Evento quando um valor é selecionado */
+    onSelectValue?: (value: any) => void;
+    /** Function que retorna o label de uma ChipItem */
+    getOptionLabel?: (option: O) => string;
+    /** Function que retorna o valor de uma ChipItem */
+    getOptionValue?: (option: O) => any;
+    /** Function que converte os valores do datasource para uma lista de chips selecionados do tipo padrão string[] ou string */
+    convertToValue?: (source: any) => string[] | string;
+    /** Function que converte o valor selecionado do tipo padrão string[] ou string para o tipo desejado */
+    convertFromValue?: (selected: string[] | string) => any;
+    /** Opções de seleção iniciais */
+    initialOptions?: O[] | object;
+    /** Coleção de ChipItem[] que representam as opções do select */
+    children?: ReactNode | ReactNode[];
+    /** Valor de entrada controlado */
+    value?: any;
+    /** Valor padrão de entrada não controlado */
+    defaultValue?: any;
+    /** Controla a aparência do chip, sendo padrão "filled" para dark theme e "outline" para light theme. ("outline" | "light" | "filled")*/
+    variant?: ChipVariant;
+    /** Tipo do chip */
+    type?: 'checkbox' | 'radio';
+    /** Permite que múltiplos valores sejam selecionados */
+    multiple?: boolean;
+    /** Estilo do chip */
+    style?: CSSProperties;
+    /** Último erro ocorrido no chip */
+    error?: string;
+    /** Título do edit */
+    label?: string;
+    /** Descrição do edit */
+    description?: string;
+}
+export declare function ArchbaseChipGroup<T, ID, O>({ dataSource, dataField, onSelectValue, getOptionLabel, getOptionValue, convertToValue, convertFromValue, value, defaultValue, initialOptions, children, variant, type, multiple, error, style, label, description, }: ArchbaseChipGroupProps<T, ID, O>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseChipItem.d.ts

@@ -0,0 +1,18 @@
+import { ChipVariant } from '@mantine/core';
+import { CSSProperties } from 'react';
+export interface ArchbaseChipItemProps<T> {
+    /** Texto a ser apresentado no select */
+    label: string;
+    /** Cor de fundo do item */
+    value?: T;
+    /** Controla a aparência do chip, sendo padrão "filled" para dark theme e "outline" para light theme. ("outline" | "light" | "filled")*/
+    variant?: ChipVariant;
+    /** Tipo do chip */
+    type?: 'checkbox' | 'radio';
+    /** Estilo do chip */
+    style?: CSSProperties;
+}
+export declare function ArchbaseChipItem<T>(_props: ArchbaseChipItemProps<T>): any;
+export declare namespace ArchbaseChipItem {
+    var displayName: string;
+}

package/dist/editors/ArchbaseColorPicker.d.ts

@@ -0,0 +1,3 @@
+export interface ArchbaseColorPickerProps {
+}
+export declare function ArchbaseColorPicker(_props: ArchbaseColorPickerProps): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseCountdownProgress.d.ts

@@ -0,0 +1,5 @@
+export interface ArchbaseCountdownProgressProps {
+    targetDate: string | Date;
+    color?: string;
+}
+export declare const ArchbaseCountdownProgress: ({ targetDate, color }: ArchbaseCountdownProgressProps) => import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseCronExpressionEdit.d.ts

@@ -0,0 +1,16 @@
+interface ArchbaseCronExpressionEditProps {
+    /** The current cron expression value */
+    value: string;
+    /** Callback function to handle changes in the cron expression */
+    onChange: (newValue: string) => void;
+    /** Label for the input field */
+    label?: string;
+    /** Error message to display (if any) */
+    error?: string;
+    /** Whether the component is in a read-only state */
+    readOnly?: boolean;
+    /** Placeholder text for the input field */
+    placeholder?: string;
+}
+export declare function ArchbaseCronExpressionEdit({ value, onChange, label, error, readOnly, placeholder }: ArchbaseCronExpressionEditProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/editors/ArchbaseCronExpressionEditor.d.ts

@@ -0,0 +1,8 @@
+export type ArchbaseCronExpressionEditorProps = {
+    onChange: (value: any) => void;
+    readOnly?: boolean;
+    initialValue: any;
+    label?: any;
+    error?: string;
+};
+export declare function ArchbaseCronExpressionEditor({ label, initialValue, onChange, readOnly, error }: ArchbaseCronExpressionEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseDatePicker.d.ts

@@ -0,0 +1,2 @@
+export { DatePicker as ArchbaseDatePicker } from '@mantine/dates';
+export type { DatePickerProps as ArchbaseDatePickerProps } from '@mantine/dates';

package/dist/editors/ArchbaseDatePickerEdit.d.ts

@@ -0,0 +1,85 @@
+import { __InputProps, CloseButtonProps, InputStylesNames, InputVariant, InputWrapperStylesNames, MantineSize, PolymorphicFactory, PopoverProps, StylesApiProps } from '@mantine/core';
+import { CalendarBaseProps, CalendarLevel, CalendarStylesNames, DecadeLevelSettings, MonthLevelSettings, YearLevelSettings } from '@mantine/dates';
+type DateValue = Date | null;
+import React, { CSSProperties } from 'react';
+import { type IArchbaseDataSourceBase } from '@archbase/data';
+export declare function assignTime(originalDate: DateValue, resultDate: DateValue): Date;
+export type ArchbaseDatePickerEditStylesNames = CalendarStylesNames | InputStylesNames | InputWrapperStylesNames;
+export interface ArchbaseDatePickerEditProps<T, ID> extends StylesApiProps<ArchbaseDatePickerEditFactory>, __InputProps, CalendarBaseProps, DecadeLevelSettings, YearLevelSettings, MonthLevelSettings, Omit<React.ComponentPropsWithoutRef<'input'>, 'size' | 'value' | 'defaultValue' | 'onChange'> {
+    /** Analisa a entrada do usuário para convertê-la em um objeto Date */
+    dateParser?: (value: string) => DateValue;
+    /** Valor do componente controlado */
+    value?: DateValue | string;
+    /** Valor padrão para componente não controlado */
+    defaultValue?: DateValue | string;
+    /** Chamado quando o valor muda */
+    onChange?(value: DateValue): void;
+    /** Evento quando o valor é alterado */
+    onChangeValue?: (value: any, event: any) => void;
+    /** Adereços adicionados ao componente Popover */
+    popoverProps?: Partial<Omit<PopoverProps, 'children'>>;
+    /** Determina se o valor de entrada pode ser limpo, adiciona o botão limpar à seção direita, falso por padrão */
+    clearable?: boolean;
+    /** Adereços adicionados ao botão limpar */
+    clearButtonProps?: CloseButtonProps;
+    /** Determina se o valor de entrada deve ser revertido para o último valor válido conhecido no desfoque, verdadeiro por padrão */
+    fixOnBlur?: boolean;
+    /** Determina se o valor pode ser desmarcado quando o usuário clica na data selecionada no calendário ou apaga o conteúdo da entrada, verdadeiro se prop limpável estiver definido, falso por padrão */
+    allowDeselect?: boolean;
+    /** Determina se o tempo (horas, minutos, segundos e milissegundos) deve ser preservado quando uma nova data é escolhida, verdadeiro por padrão */
+    preserveTime?: boolean;
+    /** Nível máximo que o usuário pode atingir (década, ano, mês), o padrão é década */
+    maxLevel?: CalendarLevel;
+    /** Nível inicial exibido ao usuário (década, ano, mês), usado para componente não controlado */
+    defaultLevel?: CalendarLevel;
+    /** Nível atual exibido ao usuário (década, ano, mês), usado para componente controlado */
+    level?: CalendarLevel;
+    /** Chamado quando o nível muda */
+    onLevelChange?(level: CalendarLevel): void;
+    /** Fonte de dados onde será atribuido o valor do datePicker (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do datePicker na fonte de dados */
+    dataField?: string;
+    /** Indicador se o date picker está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o date picker é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Estilo do date picker */
+    style?: CSSProperties;
+    /** Tamanho do date picker */
+    size?: MantineSize;
+    /** Largura do date picker */
+    width?: string | number | undefined;
+    /** Possíveis formatos para a data */
+    dateFormat?: 'DD/MM/YYYY' | 'DD-MM-YYYY' | 'YYYY/MM/DD' | 'YYYY-MM-DD';
+    /** Caracter a ser mostrado quando não houver um valor*/
+    placeholderChar?: string;
+    /** Indicador se o caracter deve ser mostrado quando não houver um valor */
+    showPlaceholderFormat?: boolean;
+    /** Evento quando o foco sai do date picker */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o date picker recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Indica se o date picker tem o preenchimento obrigatório */
+    required?: boolean;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    /** Último erro ocorrido no datepicker */
+    error?: string;
+    /** Título do edit */
+    title?: string;
+    /** Título do edit */
+    label?: string;
+}
+export type ArchbaseDatePickerEditFactory = PolymorphicFactory<{
+    props: ArchbaseDatePickerEditProps<any, any>;
+    defaultRef: HTMLInputElement;
+    defaultComponent: 'input';
+    stylesNames: ArchbaseDatePickerEditStylesNames;
+    variant: InputVariant;
+}>;
+export declare function ArchbaseDatePickerEdit<T, ID>(props: ArchbaseDatePickerEditProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseDatePickerEdit {
+    var displayName: string;
+}
+export {};

package/dist/editors/ArchbaseDatePickerRange.d.ts

@@ -0,0 +1,47 @@
+import { MantineSize } from '@mantine/core';
+import { DateValue } from '@mantine/dates';
+import React from 'react';
+import { CSSProperties, ReactNode } from 'react';
+export interface ArchbaseDatePickerRangeProps {
+    /** Indicador se o date picker range está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o date picker range é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do date picker range é obrigatório */
+    required?: boolean;
+    /** Valor inicial */
+    value?: string;
+    /** Estilo do date picker range */
+    style?: CSSProperties;
+    /** Tamanho do date picker range */
+    size?: MantineSize;
+    /** Largura do date picker range */
+    width?: string | number | undefined;
+    /** Icone à direita */
+    icon?: ReactNode;
+    /** Texto sugestão do date picker range */
+    placeholderStart?: string;
+    /** Texto sugestão do date picker range */
+    placeholderEnd?: string;
+    /** Título do date picker range */
+    label?: string;
+    /** Descrição do date picker range */
+    description?: string;
+    /** Último erro ocorrido no date picker range */
+    error?: string;
+    /** Evento quando o foco sai do date picker range */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o date picker range recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o valor do date picker range é alterado */
+    onChangeValue?: (value: any, event: any) => void;
+    onKeyDown?: (event: any) => void;
+    onKeyUp?: (event: any) => void;
+    /** Evento quando o valor do range do date picker range é alterado */
+    onSelectDateRange?: (value: DateValue[]) => void;
+    /** Referência para o componente interno data inicial*/
+    innerRefStart?: React.RefObject<HTMLInputElement> | undefined;
+    /** Referência para o componente interno data final*/
+    innerRefEnd?: React.RefObject<HTMLInputElement> | undefined;
+}
+export declare function ArchbaseDatePickerRange({ label, disabled, readOnly, size, width, style, onSelectDateRange, onFocusEnter, onFocusExit, placeholderStart, placeholderEnd, error, }: ArchbaseDatePickerRangeProps): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseDateTimePickerEdit.d.ts

@@ -0,0 +1,43 @@
+import { DateTimePickerProps } from '@mantine/dates';
+import type { CSSProperties, ForwardedRef } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+type OmittedDateTimePickerProps = Omit<DateTimePickerProps, 'value' | 'onChange'>;
+export interface ArchbaseDateTimePickerEditProps<T, ID> extends OmittedDateTimePickerProps {
+    /** Data source where the edit value will be assigned (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Field where the edit value should be assigned in the data source */
+    dataField?: string;
+    /** Indicates if the edit is disabled */
+    disabled?: boolean;
+    /** Indicates if the edit is read-only. Note: used in conjunction with data source status */
+    readOnly?: boolean;
+    /** Indicates if filling the edit is required */
+    required?: boolean;
+    /** Initial value */
+    value?: Date | null;
+    /** Edit style */
+    style?: CSSProperties;
+    /** Edit width */
+    width?: string | number | undefined;
+    /** Event occurs when focus exits the edit */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Event occurs when the edit receives focus */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Event when the edit value changes (internal use) */
+    onChange?: (value: Date | null) => void;
+    /** Event when the edit value changes (external use) */
+    onChangeValue?: (value: Date | null) => void;
+    /** Clear button properties */
+    clearButtonProps?: Record<string, any>;
+    /** With seconds input */
+    withSeconds?: boolean;
+    /** Value format */
+    valueFormat?: string;
+    /** Error message */
+    error?: string;
+}
+export declare const ArchbaseDateTimePickerEdit: <T, ID>(props: ArchbaseDateTimePickerEditProps<T, ID> & {
+    ref?: ForwardedRef<HTMLButtonElement>;
+}) => React.JSX.Element;
+export {};

package/dist/editors/ArchbaseDateTimePickerRange.d.ts

@@ -0,0 +1,58 @@
+import { MantineSize } from '@mantine/core';
+import React from 'react';
+import { CSSProperties, ReactNode } from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseDateTimePickerRangeProps<T, ID> {
+    /** Data source where the range values will be assigned (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Field for start date in the data source */
+    dataFieldStart?: string;
+    /** Field for end date in the data source */
+    dataFieldEnd?: string;
+    /** Indicates if the date picker range is disabled */
+    disabled?: boolean;
+    /** Indicates if the date picker range is read-only */
+    readOnly?: boolean;
+    /** Indicates if filling the date picker range is required */
+    required?: boolean;
+    /** Initial value */
+    value?: [Date | null, Date | null];
+    /** Style of the date picker range */
+    style?: CSSProperties;
+    /** Size of the date picker range */
+    size?: MantineSize;
+    /** Width of the date picker range */
+    width?: string | number | undefined;
+    /** Custom right section icon */
+    icon?: ReactNode;
+    /** Placeholder text for start date */
+    placeholderStart?: string;
+    /** Placeholder text for end date */
+    placeholderEnd?: string;
+    /** Label for the date picker range */
+    label?: string;
+    /** Description for the date picker range */
+    description?: string;
+    /** Error message */
+    error?: string;
+    /** Event when range value changes */
+    onRangeChange?: (value: [Date | null, Date | null]) => void;
+    /** Event when key down */
+    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    /** Event when key up */
+    onKeyUp?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    /** Minimum date allowed */
+    minDate?: Date;
+    /** Maximum date allowed */
+    maxDate?: Date;
+    /** Date format */
+    valueFormat?: string;
+    /** With seconds input */
+    withSeconds?: boolean;
+    /** Clear button properties */
+    clearButtonProps?: Record<string, any>;
+}
+export declare function ArchbaseDateTimePickerRange<T, ID>({ dataSource, dataFieldStart, dataFieldEnd, label, disabled, readOnly, size, width, style, description, onRangeChange, placeholderStart, placeholderEnd, icon, error, value, minDate, maxDate, valueFormat, withSeconds, clearButtonProps, required, }: ArchbaseDateTimePickerRangeProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseDateTimePickerRange {
+    var displayName: string;
+}

package/dist/editors/ArchbaseEdit.d.ts

@@ -0,0 +1,56 @@
+/**
+ * ArchbaseEdit — input texto integrado ao DataSource (v1/v2) com suporte a validação e estado controlado.
+ * @status stable
+ */
+import { ActionIconVariant, MantineSize } from '@mantine/core';
+import type { CSSProperties, FocusEventHandler, ReactNode } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseEditProps<T, ID> {
+    /** Fonte de dados onde será atribuido o valor do edit (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do edit na fonte de dados */
+    dataField?: string;
+    /** Indicador se o edit está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o edit é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do edit é obrigatório */
+    required?: boolean;
+    /** Valor inicial */
+    value?: string;
+    /** Estilo do edit */
+    style?: CSSProperties;
+    /** Tamanho do edit */
+    size?: MantineSize;
+    /** Largura do edit */
+    width?: string | number | undefined;
+    /** Icone à direita */
+    icon?: ReactNode;
+    /** Dica para botão localizar */
+    tooltipIconSearch?: ReactNode;
+    /** Evento ocorre quando clica no botão localizar */
+    onActionSearchExecute?: () => void;
+    /** Texto sugestão do edit */
+    placeholder?: string;
+    /** Título do edit */
+    label?: string;
+    /** Descrição do edit */
+    description?: string;
+    /** Último erro ocorrido no edit */
+    error?: string;
+    /** Evento quando o foco sai do edit */
+    onFocusExit?: FocusEventHandler<T> | undefined;
+    /** Evento quando o edit recebe o foco */
+    onFocusEnter?: FocusEventHandler<T> | undefined;
+    /** Evento quando o valor do edit é alterado */
+    onChangeValue?: (value: any, event: any) => void;
+    onKeyDown?: (event: any) => void;
+    onKeyUp?: (event: any) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    variant?: ActionIconVariant;
+    minLength?: number;
+    maxLength?: number;
+}
+export declare function ArchbaseEdit<T, ID>({ dataSource, dataField, disabled, readOnly, style, placeholder, label, description, error, required, size, width, innerRef, value, icon, onKeyDown, onKeyUp, onActionSearchExecute, tooltipIconSearch, onFocusExit, onFocusEnter, onChangeValue, variant, minLength, maxLength }: ArchbaseEditProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseEdit.example.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Exemplo prático: ArchbaseEdit híbrido suportando V1 e V2
+ *
+ * Este exemplo demonstra como o mesmo componente ArchbaseEdit
+ * funciona transparentemente com ambas as versões do DataSource
+ */
+export declare const ArchbaseEditExamples: () => import("react/jsx-runtime").JSX.Element;
+export default ArchbaseEditExamples;

package/dist/editors/ArchbaseFileAttachment.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+export interface Attachment {
+    name: string;
+    type: string;
+    size: number;
+    content: string;
+}
+export interface ArchbaseFileAttachmentProps {
+    attachments: Attachment[];
+    accept?: string[];
+    acceptDescription?: string;
+    onAttachmentAdd: (newAttachment: Attachment) => void;
+    onAttachmentRemove: (removedAttachment: Attachment) => void;
+    height?: number | string;
+    width?: number | string;
+}
+export declare const ArchbaseFileAttachment: React.FC<ArchbaseFileAttachmentProps>;

package/dist/editors/ArchbaseImageEdit.d.ts

@@ -0,0 +1,50 @@
+import { ActionIconVariant, ImageProps } from '@mantine/core';
+import React, { CSSProperties } from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseImageEditProps<T, ID> extends ImageProps {
+    /** Fonte de dados onde será atribuido o valor do rich edit (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do rich edit na fonte de dados */
+    dataField?: string;
+    /** Indicador se o rich edit está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o rich edit é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do rich edit é obrigatório */
+    required?: boolean;
+    /** Estilo do checkbox */
+    style?: CSSProperties;
+    /** Título do rich edit */
+    label?: string;
+    /** Descrição do rich edit */
+    description?: string;
+    /** Último erro ocorrido no rich edit */
+    error?: string;
+    /** Controla a aparência dos botões, sendo padrão "transparent". ("filled" | "light" | "outline" | "transparent" | "white" | "subtle" | "default" | "gradient")*/
+    variant?: ActionIconVariant;
+    /** Image src */
+    src?: string | null;
+    /** Texto alternativo da imagem, usado como título para espaço reservado se a imagem não foi carregada */
+    alt?: string;
+    /** Largura da imagem, padrão de 100%, não pode exceder 100% */
+    width?: number | string;
+    /** Altura da imagem, o padrão é a altura da imagem original ajustada para determinada largura */
+    height?: number | string;
+    /** Chave de theme.radius ou qualquer valor CSS válido para definir border-radius, 0 por padrão */
+    radius?: string | number | undefined;
+    /** Obter ref do elemento de imagem */
+    imageRef?: React.ForwardedRef<HTMLImageElement>;
+    /** Legenda da imagem, exibida abaixo da imagem */
+    caption?: React.ReactNode;
+    aspectRatio?: number | null;
+    objectFit?: 'cover' | 'contain' | 'fill' | 'revert' | 'scale-down';
+    compressInitial?: number | undefined | null;
+    onChangeImage?: (image: any) => void;
+    /** Desabilita conversão do conteúdo em base64 antes de salvar na fonte de dados */
+    disabledBase64Convertion?: boolean;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    /** Cor de fundo da imagem */
+    imageBackgroundColor?: string;
+}
+export declare function ArchbaseImageEdit<T, ID>({ width, height, dataSource, dataField, disabled, readOnly, required, label, description, error, src, radius, aspectRatio, objectFit, compressInitial, onChangeImage, disabledBase64Convertion, innerRef, variant, imageBackgroundColor, ...otherProps }: ArchbaseImageEditProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseJsonEdit.d.ts

@@ -0,0 +1,49 @@
+import { MantineSize } from '@mantine/core';
+import type { CSSProperties } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseJsonEditProps<T, ID> {
+    /** Fonte de dados onde será atribuido o valor do json input (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do json input na fonte de dados */
+    dataField?: string;
+    /** Indicador se o json input está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o json input é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do json input é obrigatório */
+    required?: boolean;
+    /** Estilo do json input */
+    style?: CSSProperties;
+    /** Tamanho do json input */
+    size?: MantineSize;
+    /** Largura do json input */
+    width?: string | number | undefined;
+    /** Indicador se json input crescerá com o conteúdo até que maxRows sejam atingidos  */
+    autosize?: boolean;
+    /** Número mínimo de linhas obrigatórias */
+    minRows?: number;
+    /** Número máximo de linhas aceitas */
+    maxRows?: number;
+    /** Tamanho máximo em caracteres aceitos */
+    maxLength?: number;
+    /** Desabilita conversão do conteúdo em base64 antes de salvar na fonte de dados */
+    disabledBase64Convertion?: boolean;
+    /** Texto sugestão do json input */
+    placeholder?: string;
+    /** Título do json input */
+    label?: string;
+    /** Descrição do json input */
+    description?: string;
+    /** Último erro ocorrido no json input */
+    error?: string;
+    /** Evento quando o foco sai do json input */
+    onFocusExit?: (event: React.FocusEvent<HTMLTextAreaElement>) => void;
+    /** Evento quando o json input recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLTextAreaElement>) => void;
+    /** Evento quando o valor do json input é alterado */
+    onChangeValue?: (value: any) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLTextAreaElement> | undefined;
+}
+export declare function ArchbaseJsonEdit<T, ID>({ dataSource, dataField, disabled, readOnly, style, placeholder, label, description, error, onFocusExit, onFocusEnter, onChangeValue, autosize, minRows, maxRows, maxLength, required, disabledBase64Convertion, innerRef, }: ArchbaseJsonEditProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseKeyValueEditor.d.ts

@@ -0,0 +1,22 @@
+interface ArchbaseKeyValueEditorProps {
+    initialValue: string;
+    keyLabel?: string;
+    valueLabel?: string;
+    valueOptions?: {
+        value: string;
+        label: string;
+    }[];
+    onChangeKeyValue: (value: string) => void;
+    pairSeparator?: string;
+    keyValueSeparator?: string;
+    useBraces?: boolean;
+    readOnly?: boolean;
+    label?: string;
+    error?: string;
+    tooltipAdd?: string;
+    tooltipRemove?: string;
+    layout?: 'horizontal' | 'vertical';
+    spacing?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+}
+export declare function ArchbaseKeyValueEditor({ initialValue, keyLabel, valueLabel, valueOptions, onChangeKeyValue, pairSeparator, keyValueSeparator, useBraces, readOnly, label, error, tooltipAdd, tooltipRemove, layout, spacing }: ArchbaseKeyValueEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/editors/ArchbaseLookupEdit.d.ts

@@ -0,0 +1,57 @@
+import { MantineSize } from '@mantine/core';
+import type { CSSProperties, ReactNode } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseLookupEditProps<T, ID, O> {
+    /** Fonte de dados onde será atribuido o valor do lookup edit (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do lookup edit na fonte de dados */
+    dataField?: string;
+    /** Campo da fonte de dados que será usado para apresentar o valor no lookup edit */
+    lookupField?: string;
+    /** Indicador se o lookup edit está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o lookup edit é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do lookup edit é obrigatório */
+    required?: boolean;
+    /** Validar ao sair do campo se localizou o valor */
+    validateOnExit?: boolean;
+    /** Mensagem caso falhe ao localizar o valor */
+    validateMessage?: string;
+    /** Estilo do lookup edit */
+    style?: CSSProperties;
+    /** Tamanho do campo */
+    size?: MantineSize;
+    /** Largura do lookup edit */
+    width?: string | number | undefined;
+    /** Texto sugestão do lookup edit */
+    placeholder?: string;
+    /** Título do lookup edit */
+    label?: string;
+    /** Descrição do lookup edit */
+    description?: string;
+    /** Último erro ocorrido no lookup edit */
+    error?: string;
+    /** Icone para apresentar lado direito do lookup edit que representa a busca */
+    iconSearch?: ReactNode;
+    /** Dica para botão localizar */
+    tooltipIconSearch?: string;
+    /** Evento ocorre quando clica no botão localizar */
+    onActionSearchExecute?: () => void;
+    /** Evento quando o foco sai do lookup edit */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o lookup edit recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o valor do lookup edit é alterado */
+    onChangeValue?: (value: any, event: any) => void;
+    /** Evento ocorre quando um valor é localizado */
+    onLookupResult?: (value: O) => void;
+    /** Evento ocorre quando se obtém um erro ao localizar valor */
+    onLookupError?: (error: string) => void;
+    /** Função responsável por localizar um valor */
+    lookupValueDelegator: (value: any) => Promise<O>;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+}
+export declare function ArchbaseLookupEdit<T, ID, O>({ dataSource, dataField, lookupField, iconSearch, disabled, readOnly, style, placeholder, label, description, error, required, size, width, lookupValueDelegator, onLookupError, onLookupResult, validateMessage, tooltipIconSearch, validateOnExit, onFocusExit, onFocusEnter, onChangeValue, onActionSearchExecute, innerRef, }: ArchbaseLookupEditProps<T, ID, O>): import("react/jsx-runtime").JSX.Element;