plataforma-fundacao-componentes 2.26.0 → 2.27.0-beta.0

package/dist/components/modal/modal.d.ts

@@ -0,0 +1,284 @@
+import { HTMLAttributes } from 'react';
+import { ModalSizes } from '../../libraries/ModalSize';
+import { ScreenSize } from '../../libraries/ScreenSizes';
+import { ButtonProps } from '../button/button';
+export interface ModalProps extends HTMLAttributes<HTMLDialogElement> {
+    compenseColPaddingContent?: boolean;
+    footer?: ButtonProps[] | JSX.Element;
+    mobileOn?: ScreenSize;
+    modalKey?: string;
+    onClose?: (modalKey?: string | number) => void;
+    preventEscExit?: boolean;
+    preventMaskExit?: boolean;
+    size?: ModalSizes;
+    tag?: 'dialog' | 'div';
+    title?: string;
+}
+export default function Modal({ className, compenseColPaddingContent, footer, id, mobileOn, modalKey, onClose, preventEscExit, preventMaskExit, size, tag, title, ...props }: ModalProps): import("react").DetailedReactHTMLElement<{
+    className: string;
+    id: string;
+    defaultChecked?: boolean | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined;
+    suppressHydrationWarning?: boolean | undefined;
+    accessKey?: string | undefined;
+    autoFocus?: boolean | undefined;
+    contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+    contextMenu?: string | undefined;
+    dir?: string | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    hidden?: boolean | undefined;
+    lang?: string | undefined;
+    nonce?: string | undefined;
+    slot?: string | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    style?: import("react").CSSProperties | undefined;
+    tabIndex?: number | undefined;
+    translate?: "yes" | "no" | undefined;
+    radioGroup?: string | undefined;
+    role?: import("react").AriaRole | undefined;
+    about?: string | undefined;
+    content?: string | undefined;
+    datatype?: string | undefined;
+    inlist?: any;
+    prefix?: string | undefined;
+    property?: string | undefined;
+    rel?: string | undefined;
+    resource?: string | undefined;
+    rev?: string | undefined;
+    typeof?: string | undefined;
+    vocab?: string | undefined;
+    autoCapitalize?: string | undefined;
+    autoCorrect?: string | undefined;
+    autoSave?: string | undefined;
+    color?: string | undefined;
+    itemProp?: string | undefined;
+    itemScope?: boolean | undefined;
+    itemType?: string | undefined;
+    itemID?: string | undefined;
+    itemRef?: string | undefined;
+    results?: number | undefined;
+    security?: string | undefined;
+    unselectable?: "on" | "off" | undefined;
+    inputMode?: "search" | "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
+    is?: string | undefined;
+    "aria-activedescendant"?: string | undefined;
+    "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    "aria-autocomplete"?: "both" | "none" | "inline" | "list" | undefined;
+    "aria-braillelabel"?: string | undefined;
+    "aria-brailleroledescription"?: string | undefined;
+    "aria-busy"?: (boolean | "true" | "false") | undefined;
+    "aria-checked"?: boolean | "true" | "false" | "mixed" | undefined;
+    "aria-colcount"?: number | undefined;
+    "aria-colindex"?: number | undefined;
+    "aria-colindextext"?: string | undefined;
+    "aria-colspan"?: number | undefined;
+    "aria-controls"?: string | undefined;
+    "aria-current"?: boolean | "true" | "false" | "time" | "page" | "step" | "location" | "date" | undefined;
+    "aria-describedby"?: string | undefined;
+    "aria-description"?: string | undefined;
+    "aria-details"?: string | undefined;
+    "aria-disabled"?: (boolean | "true" | "false") | undefined;
+    "aria-dropeffect"?: "link" | "none" | "copy" | "move" | "execute" | "popup" | undefined;
+    "aria-errormessage"?: string | undefined;
+    "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    "aria-flowto"?: string | undefined;
+    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    "aria-haspopup"?: boolean | "true" | "false" | "dialog" | "menu" | "listbox" | "grid" | "tree" | undefined;
+    "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    "aria-invalid"?: boolean | "true" | "false" | "grammar" | "spelling" | undefined;
+    "aria-keyshortcuts"?: string | undefined;
+    "aria-label"?: string | undefined;
+    "aria-labelledby"?: string | undefined;
+    "aria-level"?: number | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined;
+    "aria-modal"?: (boolean | "true" | "false") | undefined;
+    "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined;
+    "aria-owns"?: string | undefined;
+    "aria-placeholder"?: string | undefined;
+    "aria-posinset"?: number | undefined;
+    "aria-pressed"?: boolean | "true" | "false" | "mixed" | undefined;
+    "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    "aria-relevant"?: "all" | "text" | "additions" | "additions removals" | "additions text" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
+    "aria-required"?: (boolean | "true" | "false") | undefined;
+    "aria-roledescription"?: string | undefined;
+    "aria-rowcount"?: number | undefined;
+    "aria-rowindex"?: number | undefined;
+    "aria-rowindextext"?: string | undefined;
+    "aria-rowspan"?: number | undefined;
+    "aria-selected"?: (boolean | "true" | "false") | undefined;
+    "aria-setsize"?: number | undefined;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+    "aria-valuemax"?: number | undefined;
+    "aria-valuemin"?: number | undefined;
+    "aria-valuenow"?: number | undefined;
+    "aria-valuetext"?: string | undefined;
+    children?: import("react").ReactNode;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined;
+    onCopy?: import("react").ClipboardEventHandler<HTMLDialogElement> | undefined;
+    onCopyCapture?: import("react").ClipboardEventHandler<HTMLDialogElement> | undefined;
+    onCut?: import("react").ClipboardEventHandler<HTMLDialogElement> | undefined;
+    onCutCapture?: import("react").ClipboardEventHandler<HTMLDialogElement> | undefined;
+    onPaste?: import("react").ClipboardEventHandler<HTMLDialogElement> | undefined;
+    onPasteCapture?: import("react").ClipboardEventHandler<HTMLDialogElement> | undefined;
+    onCompositionEnd?: import("react").CompositionEventHandler<HTMLDialogElement> | undefined;
+    onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDialogElement> | undefined;
+    onCompositionStart?: import("react").CompositionEventHandler<HTMLDialogElement> | undefined;
+    onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDialogElement> | undefined;
+    onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDialogElement> | undefined;
+    onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDialogElement> | undefined;
+    onFocus?: import("react").FocusEventHandler<HTMLDialogElement> | undefined;
+    onFocusCapture?: import("react").FocusEventHandler<HTMLDialogElement> | undefined;
+    onBlur?: import("react").FocusEventHandler<HTMLDialogElement> | undefined;
+    onBlurCapture?: import("react").FocusEventHandler<HTMLDialogElement> | undefined;
+    onChange?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onChangeCapture?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onBeforeInput?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onBeforeInputCapture?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onInput?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onInputCapture?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onReset?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onResetCapture?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onSubmit?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onSubmitCapture?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onInvalid?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onInvalidCapture?: import("react").FormEventHandler<HTMLDialogElement> | undefined;
+    onLoad?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onLoadCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onError?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onErrorCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onKeyDown?: import("react").KeyboardEventHandler<HTMLDialogElement> | undefined;
+    onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDialogElement> | undefined;
+    onKeyPress?: import("react").KeyboardEventHandler<HTMLDialogElement> | undefined;
+    onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDialogElement> | undefined;
+    onKeyUp?: import("react").KeyboardEventHandler<HTMLDialogElement> | undefined;
+    onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDialogElement> | undefined;
+    onAbort?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onAbortCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onCanPlay?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onCanPlayCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onCanPlayThrough?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onDurationChange?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onEmptied?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onEmptiedCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onEncrypted?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onEncryptedCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onEnded?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onEndedCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onLoadedData?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onLoadedMetadata?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onLoadStart?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onLoadStartCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onPause?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onPauseCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onPlay?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onPlayCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onPlaying?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onPlayingCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onProgress?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onProgressCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onRateChange?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onRateChangeCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onResize?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onResizeCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onSeeked?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onSeekedCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onSeeking?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onSeekingCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onStalled?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onStalledCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onSuspend?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onSuspendCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onTimeUpdate?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onVolumeChange?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onWaiting?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onWaitingCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onAuxClick?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onAuxClickCapture?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onClick?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onClickCapture?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onContextMenu?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onContextMenuCapture?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onDoubleClick?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onDrag?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragCapture?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragEnd?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragEndCapture?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragEnter?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragEnterCapture?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragExit?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragExitCapture?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragLeave?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragLeaveCapture?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragOver?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragOverCapture?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragStart?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDragStartCapture?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDrop?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onDropCapture?: import("react").DragEventHandler<HTMLDialogElement> | undefined;
+    onMouseDown?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onMouseDownCapture?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onMouseEnter?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onMouseLeave?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onMouseMove?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onMouseOut?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onMouseOutCapture?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onMouseOver?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onMouseOverCapture?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onMouseUp?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onMouseUpCapture?: import("react").MouseEventHandler<HTMLDialogElement> | undefined;
+    onSelect?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onSelectCapture?: import("react").ReactEventHandler<HTMLDialogElement> | undefined;
+    onTouchCancel?: import("react").TouchEventHandler<HTMLDialogElement> | undefined;
+    onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDialogElement> | undefined;
+    onTouchEnd?: import("react").TouchEventHandler<HTMLDialogElement> | undefined;
+    onTouchEndCapture?: import("react").TouchEventHandler<HTMLDialogElement> | undefined;
+    onTouchMove?: import("react").TouchEventHandler<HTMLDialogElement> | undefined;
+    onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDialogElement> | undefined;
+    onTouchStart?: import("react").TouchEventHandler<HTMLDialogElement> | undefined;
+    onTouchStartCapture?: import("react").TouchEventHandler<HTMLDialogElement> | undefined;
+    onPointerDown?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerDownCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerMove?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerUp?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerUpCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerCancel?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerEnter?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerEnterCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerLeave?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerOver?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerOverCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerOut?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onPointerOutCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onGotPointerCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onLostPointerCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDialogElement> | undefined;
+    onScroll?: import("react").UIEventHandler<HTMLDialogElement> | undefined;
+    onScrollCapture?: import("react").UIEventHandler<HTMLDialogElement> | undefined;
+    onWheel?: import("react").WheelEventHandler<HTMLDialogElement> | undefined;
+    onWheelCapture?: import("react").WheelEventHandler<HTMLDialogElement> | undefined;
+    onAnimationStart?: import("react").AnimationEventHandler<HTMLDialogElement> | undefined;
+    onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDialogElement> | undefined;
+    onAnimationEnd?: import("react").AnimationEventHandler<HTMLDialogElement> | undefined;
+    onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDialogElement> | undefined;
+    onAnimationIteration?: import("react").AnimationEventHandler<HTMLDialogElement> | undefined;
+    onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDialogElement> | undefined;
+    onTransitionEnd?: import("react").TransitionEventHandler<HTMLDialogElement> | undefined;
+    onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDialogElement> | undefined;
+}, HTMLElement>;

package/dist/components/modal/modalMask.d.ts

@@ -0,0 +1,9 @@
+import React, { HTMLAttributes } from 'react';
+import { ScreenSize } from '../../libraries/ScreenSizes';
+interface ModalMaskProps extends HTMLAttributes<HTMLDivElement> {
+    mobileOn?: ScreenSize;
+    children?: JSX.Element;
+    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+}
+export declare const ModalMask: ({ className, mobileOn, children, ...props }: ModalMaskProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/modal/modalTypes.d.ts

@@ -0,0 +1,32 @@
+import { ModalProps } from './modal';
+export interface AlertModalProps<Req = any, Res = any> extends ModalProps {
+    language?: {
+        confirm: string;
+    };
+    onConfirm: (obj?: Req) => void | Promise<Res>;
+    disabled?: boolean;
+    showIcons?: boolean;
+}
+export declare function AlertModal({ disabled, language, onConfirm, showIcons, ...props }: AlertModalProps): import("react/jsx-runtime").JSX.Element;
+export interface ConfirmModalProps<Req = any, Res = any> extends ModalProps {
+    language?: {
+        confirm: string;
+        cancel: string;
+    };
+    onConfirm: (obj?: Req) => void | Promise<Res>;
+    onCancel: () => void;
+    showIcons?: boolean;
+    disabled?: boolean;
+}
+export declare function ConfirmModal({ disabled, language, onCancel, onConfirm, showIcons, ...props }: ConfirmModalProps): import("react/jsx-runtime").JSX.Element;
+export interface DestructiveModalProps extends ModalProps {
+    language?: {
+        confirm: string;
+        cancel: string;
+    };
+    onConfirm: () => void | Promise<any>;
+    disabled?: boolean;
+    onCancel: () => void;
+    showIcons?: boolean;
+}
+export declare function DestructiveModal({ disabled, language, onCancel, onConfirm, showIcons, ...props }: DestructiveModalProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/notification/notification.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { NotificationPosition, NotificationType } from '../../libraries/Notification';
+interface NotificationProps {
+    position?: NotificationPosition;
+    type?: NotificationType;
+    count?: number;
+    verticalOuter?: number;
+    horizontalOuter?: number;
+    className?: string;
+    children: ReactNode;
+}
+export default function Notification({ className, type, verticalOuter, horizontalOuter, position, ...props }: NotificationProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/qrcode/qrcode.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+export interface QRCodeProps {
+    button?: boolean;
+    size: number;
+    margin?: number;
+    text: string;
+    color?: string;
+    backgroundColor?: string;
+    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+}
+declare function QRCode(props: QRCodeProps): import("react/jsx-runtime").JSX.Element;
+declare namespace QRCode {
+    var defaultProps: {
+        margin: number;
+        color: string;
+    };
+}
+declare const _default: React.MemoExoticComponent<typeof QRCode>;
+export default _default;

package/dist/components/radioButton/radioButton.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { RadioButtonType } from '../../libraries/RadioButtonTheme';
+import { TooltipPosition } from '../../libraries/Tooltips';
+interface RadioButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'onChange'> {
+    'tooltip-position'?: TooltipPosition;
+    'tooltip-text'?: string;
+    value: boolean;
+    theme?: RadioButtonType;
+    onChange?: (value: boolean) => void;
+}
+declare function RadioButton({ value, theme, onChange, className, ...props }: RadioButtonProps): import("react/jsx-runtime").JSX.Element;
+declare namespace RadioButton {
+    var defaultProps: {
+        disabled: boolean;
+        value: boolean;
+        theme: RadioButtonType;
+    };
+}
+declare const _default: React.MemoExoticComponent<typeof RadioButton>;
+export default _default;

package/dist/components/row/row.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { TooltipPosition } from '../../libraries/Tooltips';
+interface RowProps extends React.HTMLAttributes<HTMLDivElement> {
+    'tooltip-position'?: TooltipPosition;
+    'tooltip-text'?: string;
+    columnDirection?: boolean;
+    centralized?: boolean;
+}
+declare function Row({ columnDirection, centralized, className, ...props }: RowProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof Row>;
+export default _default;

package/dist/components/scrollArrowOverflow/scrollArrowOverflow.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+export interface ScrollArrowOverflowProps {
+    children?: ReactNode;
+    arrows?: 'bottom' | 'left' | 'right';
+    defaultOpened?: boolean;
+}
+declare function ScrollArrowOverflow({ children, arrows, }: ScrollArrowOverflowProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ScrollArrowOverflow>;
+export default _default;

package/dist/components/scrollTainer/scrollTainer.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes } from 'react';
+export interface ScrollTainerProps extends HTMLAttributes<HTMLDivElement> {
+    active?: boolean;
+    theme?: 'default' | 'white' | 'primary' | 'dark';
+    body?: boolean;
+}
+export default function ScrollTainer({ active: ac, theme, body: changeBody, className, ...props }: ScrollTainerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/select/select.d.ts

@@ -0,0 +1,54 @@
+import React from 'react';
+import { TooltipPosition } from '../../libraries/Tooltips';
+type SelectAcceptedTypes = number | string | boolean;
+export type SelectOptionsType<T extends SelectAcceptedTypes = SelectAcceptedTypes> = {
+    label: string | number;
+    value: T | null;
+    key?: string;
+};
+type SelectPostEvent = {
+    setPanelOpened: (v: boolean) => void;
+};
+export interface SelectProps {
+    'tooltip-position'?: TooltipPosition;
+    'tooltip-text'?: string;
+    id?: string;
+    className?: string;
+    onChange: (value: any, evt: SelectPostEvent) => void;
+    value?: number | string | any[] | boolean | null;
+    label?: string;
+    placeholder?: string;
+    error?: boolean;
+    helperText?: string;
+    multiple?: boolean;
+    panelFilter?: boolean;
+    panelFilterPlaceholder?: string;
+    bottomPanel?: boolean;
+    showPanelFooter?: boolean;
+    options?: SelectOptionsType[];
+    noOptionMessage?: string;
+    multiplePlaceholder?: (number: any) => string;
+    clearButton?: boolean;
+    loading?: boolean;
+    disabled?: boolean;
+    preSelectUniqueOption?: boolean;
+    readOnly?: boolean;
+    tabIndex?: number;
+}
+declare function Select(props: SelectProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Select {
+    var defaultProps: {
+        onChange: undefined;
+        value: string;
+        multiple: boolean;
+        options: never[];
+        clearButton: boolean;
+        showPanelFooter: boolean;
+        panelFilterPlaceholder: string;
+        noOptionMessage: string;
+        multiplePlaceholder: (itens: number) => string;
+        preSelectUniqueOption: boolean;
+    };
+}
+declare const _default: React.MemoExoticComponent<typeof Select>;
+export default _default;

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

@@ -0,0 +1,15 @@
+import { CSSProperties, MouseEvent } from 'react';
+import { TooltipPosition } from '../../libraries/Tooltips';
+interface SwitchProps {
+    'tooltip-position'?: TooltipPosition;
+    'tooltip-text'?: string;
+    className?: string;
+    style?: CSSProperties;
+    disabled?: boolean;
+    value?: boolean;
+    onChange?: (value: boolean, evt: MouseEvent<HTMLButtonElement>) => void;
+    scale?: number;
+}
+declare function SwitchComponent({ className, style, scale, value, onChange, ...props }: SwitchProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof SwitchComponent>;
+export default _default;

package/dist/components/tabs/tabs.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export interface TabsProps {
+    tabs?: {
+        title: string;
+        id?: string;
+        disabled?: boolean;
+    }[];
+    justify?: 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+    onChange: (val: number) => void;
+    atual?: number | null;
+    changeTitleColor?: boolean;
+}
+declare function Tabs(props: TabsProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof Tabs>;
+export default _default;

package/dist/components/toast/toast.d.ts

@@ -0,0 +1,15 @@
+import { ToastTypes } from '../../libraries/Toast';
+export interface ToastProps {
+    id?: string;
+    label?: string;
+    theme?: ToastTypes;
+    timeout?: number;
+    showActionButton?: boolean;
+    actionButtonText?: string;
+    pauseOnFocusLoss?: boolean;
+    onActionButtonClick?: (evt?: any) => void;
+    showStatusBar?: boolean;
+    onClose?: () => void;
+    prevent?: boolean;
+}
+export default function Toast({ id, theme, showStatusBar, showActionButton, actionButtonText, ...props }: ToastProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/topLoader/topLoader.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface TopLoaderProps {
+    opened?: boolean;
+    logo?: React.ReactNode;
+    status?: string | React.ReactNode;
+}
+declare function TopLoader({ opened, logo, status }: TopLoaderProps): import("react/jsx-runtime").JSX.Element;
+declare namespace TopLoader {
+    var defaultProps: {
+        logo: import("react/jsx-runtime").JSX.Element;
+    };
+}
+export default TopLoader;

package/dist/components/typography/typography.d.ts

@@ -0,0 +1,13 @@
+import { CSSProperties, HTMLAttributes } from 'react';
+export interface TypographyProps extends HTMLAttributes<HTMLElement> {
+    variant?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'body' | 'caption' | 'small';
+    focus?: boolean;
+    alignment?: CSSProperties['textAlign'];
+    color?: 'primary' | 'secondary' | 'default';
+    format?: true | {
+        active: boolean;
+        replacers?: string[];
+    };
+}
+declare const Typography: import("react").ForwardRefExoticComponent<TypographyProps & import("react").RefAttributes<HTMLElement>>;
+export default Typography;

package/dist/hooks/index.d.ts

@@ -0,0 +1,21 @@
+import useCallbackedState from './useCallbackedState/useCallbackedState';
+import useCarouselBehaviour from './useCarouselBehaviour/useCarouselBehaviour';
+import useControlledTimer from './useControlledTimer/useControlledTimer';
+import useDebounce from './useDebounce/useDebounce';
+import useDraggableContainer from './useDraggableContainer/useDraggableContainer';
+import useDraggableScroll from './useDraggableScroll/useDraggableScroll';
+import useDropOpened from './useDropOpened/useDropOpened';
+import useHTMLShare from './useHTMLShare/useHTMLShare';
+import useModalManager from './useModalManager/useModalManager';
+import useOutsideClick from './useOutsideClick/useOutsideClick';
+import usePagination from './usePagination/usePagination';
+import useProgressiveCount from './useProgressiveCount/useProgressiveCount';
+import usePublicMenuList from './usePublicMenuList/usePublicMenuList';
+import useScreenSize from './useScreenSize/useScreenSize';
+import useScrollTo from './useScrollTo/useScrollTo';
+import useStorageState from './useStorageState/useStorageState';
+import useSystemInfo from './useSystemInfo/useSystemInfo';
+import useTimeElapsed from './useTimeElapsed/useTimeElapsed';
+import useToastManager from './useToastManager/useToastManager';
+import useValidatedState from './useValidatedState/useValidatedState';
+export { useCallbackedState, useCarouselBehaviour, useControlledTimer, useDebounce, useDraggableContainer, useDraggableScroll, useDropOpened, useHTMLShare, useModalManager, useOutsideClick, usePagination, useProgressiveCount, usePublicMenuList, useScreenSize, useScrollTo, useStorageState, useSystemInfo, useTimeElapsed, useToastManager, useValidatedState, };

package/dist/hooks/useCallbackedState/useCallbackedState.d.ts

@@ -1,2 +1,2 @@
-import { Dispatch, SetStateAction } from 'react';
-export default function useCallbackedState<T = any>(callback: (newValue: any) => void, initialValue?: T | undefined): [T | undefined, Dispatch<SetStateAction<T | undefined>>];
+import { Dispatch, SetStateAction } from 'react';
+export default function useCallbackedState<T = any>(callback: (newValue: any) => void, initialValue?: T | undefined): [T | undefined, Dispatch<SetStateAction<T | undefined>>];

package/dist/hooks/useCarouselBehaviour/useCarouselBehaviour.d.ts

@@ -1,11 +1,10 @@
-import React from 'react';
-import './useCarouselBehaviour.scss';
-interface CarouselBehaviourProps {
-    atual: number;
-    newAtual?: number;
-    setAtual: (newAtual: number) => void;
-    slides: any[];
-    draggable?: boolean;
-}
-declare function useCarouselBehaviour(props: CarouselBehaviourProps): [React.ReactNode, (newAtual: number, onScroll: boolean) => void];
-export default useCarouselBehaviour;
+import React from 'react';
+interface CarouselBehaviourProps {
+    atual: number;
+    newAtual?: number;
+    setAtual: (newAtual: number) => void;
+    slides: any[];
+    draggable?: boolean;
+}
+declare function useCarouselBehaviour(props: CarouselBehaviourProps): [React.ReactNode, (newAtual: number, onScroll: boolean) => void];
+export default useCarouselBehaviour;

package/dist/hooks/useControlledTimer/useControlledTimer.d.ts

@@ -1,12 +1,12 @@
-import { Dispatch } from 'react';
-interface useControlledTimerProps {
-    timeout?: number;
-    callbackTrigger: () => void;
-}
-export declare enum TimerStatus {
-    Running = "running",
-    Paused = "paused",
-    Stopped = "stopped"
-}
-export default function useControlledTimer(props: useControlledTimerProps): [Dispatch<'play' | 'pause' | 'restart' | 'stop'>, TimerStatus | undefined];
-export {};
+import { Dispatch } from 'react';
+interface useControlledTimerProps {
+    timeout?: number;
+    callbackTrigger: () => void;
+}
+export declare enum TimerStatus {
+    Running = "running",
+    Paused = "paused",
+    Stopped = "stopped"
+}
+export default function useControlledTimer(props: useControlledTimerProps): [Dispatch<'play' | 'pause' | 'restart' | 'stop'>, TimerStatus | undefined];
+export {};