@archbase/components 3.0.25 → 4.0.1

package/dist/display/ArchbaseAnimationWrapper.d.ts

@@ -0,0 +1,73 @@
+import { default as React, ReactNode } from 'react';
+export type ArchbaseAnimationPreset = 'fade' | 'scale' | 'scale-y' | 'scale-x' | 'skew-up' | 'skew-down' | 'rotate-left' | 'rotate-right' | 'slide-down' | 'slide-up' | 'slide-left' | 'slide-right' | 'pop' | 'pop-bottom-left' | 'pop-bottom-right' | 'pop-top-left' | 'pop-top-right';
+export interface ArchbaseAnimationWrapperProps {
+    /** Conteúdo a ser animado */
+    children: ReactNode;
+    /** Se o conteúdo está visível */
+    visible?: boolean;
+    /** Preset de animação */
+    preset?: ArchbaseAnimationPreset;
+    /** Duração da animação em ms */
+    duration?: number;
+    /** Delay antes de iniciar em ms */
+    delay?: number;
+    /** Função de timing */
+    timingFunction?: string;
+    /** Se deve manter montado quando invisível */
+    keepMounted?: boolean;
+    /** Callback quando a animação de entrada completa */
+    onEntered?: () => void;
+    /** Callback quando a animação de saída completa */
+    onExited?: () => void;
+    /** Callback quando a animação de entrada inicia */
+    onEnter?: () => void;
+    /** Callback quando a animação de saída inicia */
+    onExit?: () => void;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseAnimationWrapper: React.ForwardRefExoticComponent<ArchbaseAnimationWrapperProps & React.RefAttributes<HTMLDivElement>>;
+export interface ArchbaseAnimatedListProps {
+    /** Itens da lista */
+    children: ReactNode;
+    /** Se os itens estão visíveis */
+    visible?: boolean;
+    /** Preset de animação */
+    preset?: ArchbaseAnimationPreset;
+    /** Duração da animação em ms */
+    duration?: number;
+    /** Delay base em ms */
+    baseDelay?: number;
+    /** Delay incremental entre itens em ms */
+    staggerDelay?: number;
+    /** Função de timing */
+    timingFunction?: string;
+    /** Se deve animar na ordem reversa */
+    reverse?: boolean;
+    /** Classe CSS do container */
+    className?: string;
+    /** Estilo do container */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseAnimatedList: React.ForwardRefExoticComponent<ArchbaseAnimatedListProps & React.RefAttributes<HTMLDivElement>>;
+export interface ArchbaseFadeInWhenVisibleProps {
+    /** Conteúdo a ser animado */
+    children: ReactNode;
+    /** Preset de animação */
+    preset?: ArchbaseAnimationPreset;
+    /** Duração da animação em ms */
+    duration?: number;
+    /** Delay antes de iniciar em ms */
+    delay?: number;
+    /** Threshold de visibilidade (0-1) */
+    threshold?: number;
+    /** Se deve animar apenas uma vez */
+    once?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseFadeInWhenVisible: React.ForwardRefExoticComponent<ArchbaseFadeInWhenVisibleProps & React.RefAttributes<HTMLDivElement>>;

package/dist/display/ArchbaseBarcodeGenerator.d.ts

@@ -0,0 +1,50 @@
+import { BoxProps } from '@mantine/core';
+export type BarcodeFormat = 'CODE128' | 'CODE128A' | 'CODE128B' | 'CODE128C' | 'EAN13' | 'EAN8' | 'EAN5' | 'EAN2' | 'UPC' | 'UPCE' | 'ITF14' | 'ITF' | 'MSI' | 'MSI10' | 'MSI11' | 'MSI1010' | 'MSI1110' | 'pharmacode' | 'codabar';
+export interface ArchbaseBarcodeGeneratorProps extends Omit<BoxProps, 'children'> {
+    /** Valor a ser codificado */
+    value: string;
+    /** Formato do código de barras */
+    format?: BarcodeFormat;
+    /** Largura de cada barra */
+    width?: number;
+    /** Altura das barras */
+    height?: number;
+    /** Mostrar valor abaixo do código */
+    displayValue?: boolean;
+    /** Cor de fundo */
+    background?: string;
+    /** Cor das linhas */
+    lineColor?: string;
+    /** Margem ao redor */
+    margin?: number;
+    /** Fonte do texto */
+    font?: string;
+    /** Tamanho da fonte */
+    fontSize?: number;
+    /** Alinhamento do texto */
+    textAlign?: 'left' | 'center' | 'right';
+    /** Posição do texto */
+    textPosition?: 'bottom' | 'top';
+    /** Margem do texto */
+    textMargin?: number;
+    /** Mostrar botões de ação (download, copiar) */
+    showActions?: boolean;
+    /** Nome do arquivo para download */
+    downloadFilename?: string;
+    /** Callback quando código é gerado */
+    onGenerated?: () => void;
+    /** Callback de erro */
+    onError?: (error: Error) => void;
+    /** Label opcional */
+    label?: string;
+}
+export declare function ArchbaseBarcodeGenerator({ value, format, width, height, displayValue, background, lineColor, margin, font, fontSize, textAlign, textPosition, textMargin, showActions, downloadFilename, onGenerated, onError, label, ...boxProps }: ArchbaseBarcodeGeneratorProps): import("react/jsx-runtime").JSX.Element;
+/** Gerador de código EAN-13 */
+export declare function ArchbaseEAN13Generator(props: Omit<ArchbaseBarcodeGeneratorProps, 'format'>): import("react/jsx-runtime").JSX.Element;
+/** Gerador de código EAN-8 */
+export declare function ArchbaseEAN8Generator(props: Omit<ArchbaseBarcodeGeneratorProps, 'format'>): import("react/jsx-runtime").JSX.Element;
+/** Gerador de código UPC */
+export declare function ArchbaseUPCGenerator(props: Omit<ArchbaseBarcodeGeneratorProps, 'format'>): import("react/jsx-runtime").JSX.Element;
+/** Gerador de código CODE128 */
+export declare function ArchbaseCODE128Generator(props: Omit<ArchbaseBarcodeGeneratorProps, 'format'>): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseBarcodeGenerator;

package/dist/display/ArchbaseCarousel.d.ts

@@ -0,0 +1,100 @@
+import { ReactNode } from 'react';
+import { BoxProps } from '@mantine/core';
+export interface ArchbaseCarouselProps extends Omit<BoxProps, 'children'> {
+    /** Slides do carousel */
+    children: ReactNode[];
+    /** Slide inicial (0-indexed) */
+    initialSlide?: number;
+    /** Slides visíveis por vez */
+    slidesToShow?: number;
+    /** Slides para avançar por clique */
+    slidesToScroll?: number;
+    /** Gap entre slides em pixels */
+    gap?: number;
+    /** Mostrar controles de navegação */
+    showControls?: boolean;
+    /** Posição dos controles */
+    controlsPosition?: 'sides' | 'bottom' | 'bottom-right';
+    /** Tamanho dos controles */
+    controlSize?: number;
+    /** Mostrar indicadores (dots) */
+    showIndicators?: boolean;
+    /** Posição dos indicadores */
+    indicatorsPosition?: 'bottom' | 'top';
+    /** Loop infinito */
+    loop?: boolean;
+    /** Autoplay */
+    autoplay?: boolean;
+    /** Intervalo do autoplay em ms */
+    autoplayInterval?: number;
+    /** Pausar autoplay no hover */
+    pauseOnHover?: boolean;
+    /** Mostrar botão de play/pause */
+    showPlayPause?: boolean;
+    /** Animação de transição */
+    transitionDuration?: number;
+    /** Função de easing */
+    transitionTimingFunction?: string;
+    /** Callback ao mudar slide */
+    onSlideChange?: (index: number) => void;
+    /** Altura do carousel */
+    height?: number | string;
+    /** Controle externo do slide atual */
+    activeSlide?: number;
+    /** Arrastar para navegar */
+    draggable?: boolean;
+    /** Alinhamento dos slides */
+    align?: 'start' | 'center' | 'end';
+    /** Orientação */
+    orientation?: 'horizontal' | 'vertical';
+}
+export declare function ArchbaseCarousel({ children, initialSlide, slidesToShow, slidesToScroll, gap, showControls, controlsPosition, controlSize, showIndicators, indicatorsPosition, loop, autoplay, autoplayInterval, pauseOnHover, showPlayPause, transitionDuration, transitionTimingFunction, onSlideChange, height, activeSlide: controlledSlide, draggable, align, orientation, ...boxProps }: ArchbaseCarouselProps): import("react/jsx-runtime").JSX.Element;
+export interface ArchbaseCarouselSlideProps extends BoxProps {
+    children: ReactNode;
+}
+export declare function ArchbaseCarouselSlide({ children, ...props }: ArchbaseCarouselSlideProps): import("react/jsx-runtime").JSX.Element;
+export interface ImageSlide {
+    src: string;
+    alt?: string;
+    title?: string;
+    description?: string;
+}
+export interface ArchbaseImageCarouselProps extends Omit<ArchbaseCarouselProps, 'children'> {
+    /** Array de imagens */
+    images: ImageSlide[];
+    /** Object fit das imagens */
+    objectFit?: 'cover' | 'contain' | 'fill' | 'none';
+    /** Mostrar overlay com título/descrição */
+    showOverlay?: boolean;
+    /** Posição do overlay */
+    overlayPosition?: 'bottom' | 'top' | 'center';
+    /** Callback ao clicar em uma imagem */
+    onImageClick?: (image: ImageSlide, index: number) => void;
+}
+export declare function ArchbaseImageCarousel({ images, objectFit, showOverlay, overlayPosition, onImageClick, ...carouselProps }: ArchbaseImageCarouselProps): import("react/jsx-runtime").JSX.Element;
+export interface ArchbaseCardCarouselProps extends Omit<ArchbaseCarouselProps, 'children'> {
+    /** Renderizador de card */
+    renderCard: (index: number) => ReactNode;
+    /** Total de cards */
+    totalCards: number;
+}
+export declare function ArchbaseCardCarousel({ renderCard, totalCards, slidesToShow, gap, ...carouselProps }: ArchbaseCardCarouselProps): import("react/jsx-runtime").JSX.Element;
+export interface UseArchbaseCarouselOptions {
+    totalSlides: number;
+    slidesToShow?: number;
+    slidesToScroll?: number;
+    loop?: boolean;
+    initialSlide?: number;
+}
+export declare function useArchbaseCarousel({ totalSlides, slidesToShow, slidesToScroll, loop, initialSlide, }: UseArchbaseCarouselOptions): {
+    activeSlide: number;
+    setActiveSlide: (index: number) => void;
+    goToPrev: () => void;
+    goToNext: () => void;
+    goToFirst: () => void;
+    goToLast: () => void;
+    canGoPrev: boolean;
+    canGoNext: boolean;
+    maxSlide: number;
+};
+export default ArchbaseCarousel;

package/dist/display/ArchbaseCodeViewer.d.ts

@@ -0,0 +1,63 @@
+import { default as React, CSSProperties } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseCodeViewerTab {
+    /** Nome do arquivo exibido na aba */
+    fileName: string;
+    /** Codigo-fonte da aba */
+    code: string;
+    /** Linguagem para syntax highlighting */
+    language: string;
+    /** Icone opcional da aba */
+    icon?: React.ReactNode;
+}
+export interface ArchbaseCodeViewerProps<T> {
+    /** Fonte de dados onde sera lido o valor do codigo (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo de onde sera lido o valor do codigo na fonte de dados */
+    dataField?: string;
+    /** Valor do codigo (standalone) */
+    value?: string;
+    /** Alias para value */
+    code?: string;
+    /** Linguagem para syntax highlighting @default 'typescript' */
+    language?: string;
+    /** Exibir numeros de linha @default true */
+    showLineNumbers?: boolean;
+    /** Exibir botao de copiar @default true */
+    showCopyButton?: boolean;
+    /** Label do componente */
+    label?: string;
+    /** Descricao do componente */
+    description?: string;
+    /** Mensagem de erro */
+    error?: string;
+    /** Linhas destacadas */
+    highlightLines?: Record<string, {
+        color: string;
+        label?: string;
+    }>;
+    /** Altura maxima com scroll */
+    maxHeight?: string | number;
+    /** Estilo CSS */
+    style?: CSSProperties;
+    /** Classe CSS */
+    className?: string;
+    /** Largura do componente */
+    width?: string | number;
+    /** Quando fornecido, renderiza CodeHighlightTabs em vez de CodeHighlight */
+    tabs?: ArchbaseCodeViewerTab[];
+    /** Exibir borda ao redor do codigo @default false */
+    withBorder?: boolean;
+    /** Border radius @default 'sm' */
+    radius?: string | number;
+    /** Label do botao de copiar @default 'Copiar' */
+    copyLabel?: string;
+    /** Label do botao apos copiar @default 'Copiado' */
+    copiedLabel?: string;
+    /** Exibir botao de expandir/colapsar @default false */
+    withExpandButton?: boolean;
+}
+export declare function ArchbaseCodeViewer<T>({ dataSource, dataField, value, code, language, showLineNumbers: _showLineNumbers, showCopyButton, label, description, error, highlightLines: _highlightLines, maxHeight, style, className, width, tabs, withBorder, radius, copyLabel, copiedLabel, withExpandButton, }: ArchbaseCodeViewerProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseCodeViewer {
+    var displayName: string;
+}

package/dist/display/ArchbaseDiffViewer.d.ts

@@ -0,0 +1,41 @@
+import { CSSProperties, default as React } from 'react';
+import { DiffMethod } from 'react-diff-viewer-continued';
+export { DiffMethod } from 'react-diff-viewer-continued';
+export interface ArchbaseDiffViewerProps {
+    /** Texto original (lado esquerdo) */
+    oldValue: string;
+    /** Texto novo (lado direito) */
+    newValue: string;
+    /** Exibir em modo split (lado a lado) ou unificado */
+    splitView?: boolean;
+    /** Exibir apenas as diferenças */
+    showDiffOnly?: boolean;
+    /** Titulo do painel esquerdo */
+    leftTitle?: string;
+    /** Titulo do painel direito */
+    rightTitle?: string;
+    /** Linguagem para syntax highlighting */
+    language?: string;
+    /** Metodo de comparacao */
+    compareMethod?: DiffMethod;
+    /** Titulo do componente */
+    label?: string;
+    /** Descricao do componente */
+    description?: string;
+    /** Estilo do componente */
+    style?: CSSProperties;
+    /** Classe CSS do componente */
+    className?: string;
+    /** Largura do componente */
+    width?: string | number;
+    /** Altura maxima do componente (com scroll) */
+    height?: string | number;
+    /** Usar tema escuro (auto-detectado do Mantine se nao informado) */
+    useDarkTheme?: boolean;
+    /** Ocultar numeros de linha */
+    hideLineNumbers?: boolean;
+    /** Linhas de contexto ao redor das diferencas */
+    extraLinesSurroundingDiff?: number;
+}
+declare const ArchbaseDiffViewer: React.FC<ArchbaseDiffViewerProps>;
+export { ArchbaseDiffViewer };

package/dist/display/ArchbaseJsonTree.d.ts

@@ -0,0 +1,34 @@
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseJsonTreeProps<T> {
+    /** DataSource to read the JSON object/string from */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Field name within the DataSource */
+    dataField?: string;
+    /** Standalone JSON data (object or JSON string) */
+    data?: object | string;
+    /** Label for Input.Wrapper */
+    label?: string;
+    /** Description for Input.Wrapper */
+    description?: string;
+    /** Error message for Input.Wrapper */
+    error?: string;
+    /** Whether nodes are expanded by default (default: true) */
+    defaultExpanded?: boolean;
+    /** Maximum depth to expand nodes */
+    maxDepth?: number;
+    /** Whether clicking a node expands/collapses it (default: true) */
+    clickToExpandNode?: boolean;
+    /** Custom style */
+    style?: React.CSSProperties;
+    /** Custom class name */
+    className?: string;
+    /** Width of the container */
+    width?: string | number;
+    /** Max height of the container (enables scroll) */
+    maxHeight?: string | number;
+}
+declare function ArchbaseJsonTree<T>({ dataSource, dataField, data: dataProp, label, description, error, defaultExpanded, maxDepth, clickToExpandNode, style, className, width, maxHeight, }: ArchbaseJsonTreeProps<T>): import("react/jsx-runtime").JSX.Element;
+declare namespace ArchbaseJsonTree {
+    var displayName: string;
+}
+export { ArchbaseJsonTree };

package/dist/display/ArchbaseLightbox.d.ts

@@ -0,0 +1,89 @@
+import { ReactNode } from 'react';
+import { LightboxExternalProps } from 'yet-another-react-lightbox';
+export interface ArchbaseLightboxSlide {
+    /** URL da imagem */
+    src: string;
+    /** Título da imagem */
+    title?: string;
+    /** Descrição da imagem */
+    description?: string;
+    /** Texto alternativo */
+    alt?: string;
+    /** Largura da imagem (para otimização) */
+    width?: number;
+    /** Altura da imagem (para otimização) */
+    height?: number;
+    /** URL para download (se diferente de src) */
+    downloadUrl?: string;
+    /** Nome do arquivo para download */
+    downloadFilename?: string;
+}
+export interface ArchbaseLightboxProps extends Omit<LightboxExternalProps, 'slides' | 'open' | 'close'> {
+    /** Array de slides/imagens */
+    slides: ArchbaseLightboxSlide[];
+    /** Índice inicial do slide */
+    index?: number;
+    /** Se o lightbox está aberto */
+    open: boolean;
+    /** Callback ao fechar */
+    onClose: () => void;
+    /** Habilita zoom */
+    enableZoom?: boolean;
+    /** Habilita thumbnails */
+    enableThumbnails?: boolean;
+    /** Habilita slideshow */
+    enableSlideshow?: boolean;
+    /** Habilita fullscreen */
+    enableFullscreen?: boolean;
+    /** Habilita download */
+    enableDownload?: boolean;
+    /** Mostra contador */
+    showCounter?: boolean;
+    /** Mostra captions (título/descrição) */
+    showCaptions?: boolean;
+    /** Intervalo do slideshow em ms */
+    slideshowDelay?: number;
+    /** Nível máximo de zoom */
+    maxZoomPixelRatio?: number;
+    /** Callback ao mudar de slide */
+    onSlideChange?: (index: number) => void;
+}
+export interface UseArchbaseLightboxReturn {
+    /** Se o lightbox está aberto */
+    isOpen: boolean;
+    /** Índice atual */
+    currentIndex: number;
+    /** Slides configurados */
+    slides: ArchbaseLightboxSlide[];
+    /** Abre o lightbox */
+    open: (slides: ArchbaseLightboxSlide[], index?: number) => void;
+    /** Fecha o lightbox */
+    close: () => void;
+    /** Vai para um slide específico */
+    goTo: (index: number) => void;
+    /** Props para passar ao componente */
+    lightboxProps: {
+        slides: ArchbaseLightboxSlide[];
+        index: number;
+        open: boolean;
+        onClose: () => void;
+        onSlideChange: (index: number) => void;
+    };
+}
+export declare function useArchbaseLightbox(): UseArchbaseLightboxReturn;
+interface LightboxContextType {
+    open: (slides: ArchbaseLightboxSlide[], index?: number) => void;
+    close: () => void;
+}
+export declare function useArchbaseLightboxContext(): LightboxContextType;
+export interface ArchbaseLightboxProviderProps {
+    children: ReactNode;
+    /** Props padrão para o lightbox */
+    defaultProps?: Partial<ArchbaseLightboxProps>;
+}
+export declare function ArchbaseLightboxProvider({ children, defaultProps }: ArchbaseLightboxProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function ArchbaseLightbox({ slides, index, open, onClose, enableZoom, enableThumbnails, enableSlideshow, enableFullscreen, enableDownload, showCounter, showCaptions, slideshowDelay, maxZoomPixelRatio, onSlideChange, ...rest }: ArchbaseLightboxProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseLightbox {
+    var displayName: string;
+}
+export default ArchbaseLightbox;

package/dist/display/ArchbaseMarquee.d.ts

@@ -0,0 +1,46 @@
+import { ReactNode } from 'react';
+import { BoxProps } from '@mantine/core';
+export type MarqueeDirection = 'left' | 'right' | 'up' | 'down';
+export interface ArchbaseMarqueeProps extends Omit<BoxProps, 'children'> {
+    /** Conteúdo a ser animado */
+    children: ReactNode;
+    /** Direção do movimento */
+    direction?: MarqueeDirection;
+    /** Velocidade em pixels por segundo */
+    speed?: number;
+    /** Pausar ao passar o mouse */
+    pauseOnHover?: boolean;
+    /** Pausar ao clicar */
+    pauseOnClick?: boolean;
+    /** Número de cópias do conteúdo (para loop contínuo) */
+    copies?: number;
+    /** Gap entre as cópias */
+    gap?: number;
+    /** Gradient fade nas bordas */
+    gradient?: boolean;
+    /** Largura do gradient em pixels */
+    gradientWidth?: number;
+    /** Cor do gradient (background) */
+    gradientColor?: string;
+    /** Desabilitar animação */
+    disabled?: boolean;
+    /** Delay antes de iniciar (ms) */
+    delay?: number;
+}
+export declare function ArchbaseMarquee({ children, direction, speed, pauseOnHover, pauseOnClick, copies, gap, gradient, gradientWidth, gradientColor, disabled, delay, ...boxProps }: ArchbaseMarqueeProps): import("react/jsx-runtime").JSX.Element;
+/** Marquee horizontal da esquerda para direita */
+export declare function ArchbaseMarqueeLeft(props: Omit<ArchbaseMarqueeProps, 'direction'>): import("react/jsx-runtime").JSX.Element;
+/** Marquee horizontal da direita para esquerda */
+export declare function ArchbaseMarqueeRight(props: Omit<ArchbaseMarqueeProps, 'direction'>): import("react/jsx-runtime").JSX.Element;
+/** Marquee vertical de cima para baixo */
+export declare function ArchbaseMarqueeUp(props: Omit<ArchbaseMarqueeProps, 'direction'>): import("react/jsx-runtime").JSX.Element;
+/** Marquee vertical de baixo para cima */
+export declare function ArchbaseMarqueeDown(props: Omit<ArchbaseMarqueeProps, 'direction'>): import("react/jsx-runtime").JSX.Element;
+export interface ArchbaseTextTickerProps extends Omit<ArchbaseMarqueeProps, 'children'> {
+    /** Array de textos */
+    items: string[];
+    /** Separador entre itens */
+    separator?: ReactNode;
+}
+export declare function ArchbaseTextTicker({ items, separator, ...props }: ArchbaseTextTickerProps): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseMarquee;

package/dist/display/ArchbasePhotoAlbum.d.ts

@@ -0,0 +1,58 @@
+import { default as React } from 'react';
+import { Photo } from 'react-photo-album';
+export type ArchbasePhotoAlbumLayout = 'rows' | 'columns' | 'masonry';
+export interface ArchbasePhotoAlbumPhoto extends Photo {
+    /** Título da foto */
+    title?: string;
+    /** Descrição da foto */
+    description?: string;
+    /** ID único (para tracking) */
+    id?: string | number;
+    /** Badge/tag para exibir */
+    badge?: string;
+    /** Cor do badge */
+    badgeColor?: string;
+    /** Se é favorito */
+    favorite?: boolean;
+    /** Dados extras */
+    data?: Record<string, unknown>;
+}
+export interface ArchbasePhotoAlbumProps {
+    /** Array de fotos */
+    photos: ArchbasePhotoAlbumPhoto[];
+    /** Tipo de layout */
+    layout?: ArchbasePhotoAlbumLayout;
+    /** Espaçamento entre fotos (px) */
+    spacing?: number;
+    /** Padding interno (px) */
+    padding?: number;
+    /** Altura alvo das linhas (layout 'rows') */
+    targetRowHeight?: number;
+    /** Número de colunas (layout 'columns' ou 'masonry') */
+    columns?: number | ((containerWidth: number) => number);
+    /** Callback ao clicar em uma foto */
+    onClick?: (photo: ArchbasePhotoAlbumPhoto, index: number) => void;
+    /** Abre lightbox automaticamente ao clicar */
+    withLightbox?: boolean;
+    /** Mostra overlay com ações ao hover */
+    showOverlay?: boolean;
+    /** Mostra badge nas fotos */
+    showBadge?: boolean;
+    /** Mostra indicador de favorito */
+    showFavorite?: boolean;
+    /** Callback ao favoritar */
+    onFavorite?: (photo: ArchbasePhotoAlbumPhoto, index: number) => void;
+    /** Callback ao baixar */
+    onDownload?: (photo: ArchbasePhotoAlbumPhoto, index: number) => void;
+    /** Border radius das fotos */
+    borderRadius?: number;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare function ArchbasePhotoAlbum({ photos, layout, spacing, padding, targetRowHeight, columns, onClick, withLightbox, showOverlay, showBadge, showFavorite, onFavorite, onDownload, borderRadius, className, style, }: ArchbasePhotoAlbumProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbasePhotoAlbum {
+    var displayName: string;
+}
+export default ArchbasePhotoAlbum;

package/dist/display/ArchbaseQRCode.d.ts

@@ -0,0 +1,44 @@
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseQRCodeImageSettings {
+    src: string;
+    height: number;
+    width: number;
+    excavate: boolean;
+}
+export interface ArchbaseQRCodeProps<T> {
+    /** DataSource to read the string value from */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Field name within the DataSource */
+    dataField?: string;
+    /** Standalone string value to encode */
+    value?: string;
+    /** Render as SVG or Canvas */
+    renderAs?: 'svg' | 'canvas';
+    /** Size in pixels */
+    size?: number;
+    /** Error correction level */
+    level?: 'L' | 'M' | 'Q' | 'H';
+    /** Background color (dark mode aware) */
+    bgColor?: string;
+    /** Foreground color (dark mode aware) */
+    fgColor?: string;
+    /** Include margin around the QR code */
+    includeMargin?: boolean;
+    /** Optional logo/image in the center of the QR code */
+    imageSettings?: ArchbaseQRCodeImageSettings;
+    /** Label for Input.Wrapper */
+    label?: string;
+    /** Description for Input.Wrapper */
+    description?: string;
+    /** Error message for Input.Wrapper */
+    error?: string;
+    /** Custom style */
+    style?: React.CSSProperties;
+    /** Custom class name */
+    className?: string;
+}
+declare function ArchbaseQRCode<T>({ dataSource, dataField, value: valueProp, renderAs, size, level, bgColor, fgColor, includeMargin, imageSettings, label, description, error, style, className, }: ArchbaseQRCodeProps<T>): import("react/jsx-runtime").JSX.Element;
+declare namespace ArchbaseQRCode {
+    var displayName: string;
+}
+export { ArchbaseQRCode };