@archbase/components 3.0.0

package/dist/theme-editor/utils/themeExport.d.ts

@@ -0,0 +1,198 @@
+import type { MantineTheme } from '@mantine/core';
+import type { ThemeExportFormat } from '../ArchbaseThemeEditor.types';
+/**
+ * Presets de cores
+ */
+export declare const COLOR_PRESETS: ({
+    name: string;
+    colors: {
+        blue: string;
+        'blue-light': string;
+        'blue-dark': string;
+        green?: undefined;
+        'green-light'?: undefined;
+        'green-dark'?: undefined;
+        red?: undefined;
+        'red-light'?: undefined;
+        'red-dark'?: undefined;
+        orange?: undefined;
+        'orange-light'?: undefined;
+        'orange-dark'?: undefined;
+        purple?: undefined;
+        'purple-light'?: undefined;
+        'purple-dark'?: undefined;
+        dark?: undefined;
+        gray?: undefined;
+        'gray-light'?: undefined;
+    };
+} | {
+    name: string;
+    colors: {
+        green: string;
+        'green-light': string;
+        'green-dark': string;
+        blue?: undefined;
+        'blue-light'?: undefined;
+        'blue-dark'?: undefined;
+        red?: undefined;
+        'red-light'?: undefined;
+        'red-dark'?: undefined;
+        orange?: undefined;
+        'orange-light'?: undefined;
+        'orange-dark'?: undefined;
+        purple?: undefined;
+        'purple-light'?: undefined;
+        'purple-dark'?: undefined;
+        dark?: undefined;
+        gray?: undefined;
+        'gray-light'?: undefined;
+    };
+} | {
+    name: string;
+    colors: {
+        red: string;
+        'red-light': string;
+        'red-dark': string;
+        blue?: undefined;
+        'blue-light'?: undefined;
+        'blue-dark'?: undefined;
+        green?: undefined;
+        'green-light'?: undefined;
+        'green-dark'?: undefined;
+        orange?: undefined;
+        'orange-light'?: undefined;
+        'orange-dark'?: undefined;
+        purple?: undefined;
+        'purple-light'?: undefined;
+        'purple-dark'?: undefined;
+        dark?: undefined;
+        gray?: undefined;
+        'gray-light'?: undefined;
+    };
+} | {
+    name: string;
+    colors: {
+        orange: string;
+        'orange-light': string;
+        'orange-dark': string;
+        blue?: undefined;
+        'blue-light'?: undefined;
+        'blue-dark'?: undefined;
+        green?: undefined;
+        'green-light'?: undefined;
+        'green-dark'?: undefined;
+        red?: undefined;
+        'red-light'?: undefined;
+        'red-dark'?: undefined;
+        purple?: undefined;
+        'purple-light'?: undefined;
+        'purple-dark'?: undefined;
+        dark?: undefined;
+        gray?: undefined;
+        'gray-light'?: undefined;
+    };
+} | {
+    name: string;
+    colors: {
+        purple: string;
+        'purple-light': string;
+        'purple-dark': string;
+        blue?: undefined;
+        'blue-light'?: undefined;
+        'blue-dark'?: undefined;
+        green?: undefined;
+        'green-light'?: undefined;
+        'green-dark'?: undefined;
+        red?: undefined;
+        'red-light'?: undefined;
+        'red-dark'?: undefined;
+        orange?: undefined;
+        'orange-light'?: undefined;
+        'orange-dark'?: undefined;
+        dark?: undefined;
+        gray?: undefined;
+        'gray-light'?: undefined;
+    };
+} | {
+    name: string;
+    colors: {
+        dark: string;
+        gray: string;
+        'gray-light': string;
+        blue?: undefined;
+        'blue-light'?: undefined;
+        'blue-dark'?: undefined;
+        green?: undefined;
+        'green-light'?: undefined;
+        'green-dark'?: undefined;
+        red?: undefined;
+        'red-light'?: undefined;
+        'red-dark'?: undefined;
+        orange?: undefined;
+        'orange-light'?: undefined;
+        'orange-dark'?: undefined;
+        purple?: undefined;
+        'purple-light'?: undefined;
+        'purple-dark'?: undefined;
+    };
+})[];
+/**
+ * Exporta tema como JSON
+ */
+export declare function exportThemeAsJSON(theme: Partial<MantineTheme>): string;
+/**
+ * Exporta tema como TypeScript
+ */
+export declare function exportThemeAsTypeScript(theme: Partial<MantineTheme>, themeName?: string): string;
+/**
+ * Exporta tema como CSS variables
+ */
+export declare function exportThemeAsCSS(theme: Partial<MantineTheme>, prefix?: string): string;
+/**
+ * Exporta tema no formato do Mantine (para usar no createTheme)
+ */
+export declare function exportThemeForMantine(theme: Partial<MantineTheme>): string;
+/**
+ * Exporta tema em formato especificado
+ */
+export declare function exportTheme(theme: Partial<MantineTheme>, format: ThemeExportFormat, themeName?: string): string;
+/**
+ * Baixa tema como arquivo
+ */
+export declare function downloadTheme(theme: Partial<MantineTheme>, format: ThemeExportFormat, filename?: string): void;
+/**
+ * Copia tema para clipboard
+ */
+export declare function copyThemeToClipboard(theme: Partial<MantineTheme>, format: ThemeExportFormat, themeName?: string): Promise<boolean>;
+/**
+ * Merge tema com defaults
+ */
+export declare function mergeTheme(base: Partial<MantineTheme>, override: Partial<MantineTheme>): Partial<MantineTheme>;
+/**
+ * Extrai paleta de cores de um tema
+ */
+export declare function extractColorPalette(theme: MantineTheme): Record<string, string>;
+/**
+ * Cria tema a partir de preset
+ */
+export declare function themeFromPreset(presetName: string, customColors?: Record<string, string>): Partial<MantineTheme>;
+/**
+ * Valida se cor é válida (hex, rgb, etc)
+ */
+export declare function isValidColor(color: string): boolean;
+/**
+ * Converte hex para RGB
+ */
+export declare function hexToRgb(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+} | null;
+/**
+ * Converte RGB para hex
+ */
+export declare function rgbToHex(r: number, g: number, b: number): string;
+/**
+ * Gera escala de cores a partir de uma cor base
+ */
+export declare function generateColorScale(baseColor: string): string[];

package/dist/themes/ArchbaseThemeEditor.d.ts

@@ -0,0 +1,49 @@
+import { MantineSize } from '@mantine/core';
+import type { CSSProperties, FocusEventHandler, ReactNode } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseThemeEditorProps<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?: string;
+    /** 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;
+}
+export declare function ArchbaseThemeEditor<T, ID>({ dataSource, dataField, value, onChangeValue, disabled, readOnly, ...props }: ArchbaseThemeEditorProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/types/index.d.ts

@@ -0,0 +1,106 @@
+import { CSSProperties, FocusEventHandler, RefObject } from 'react';
+import { MantineSize } from '@mantine/core';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+/**
+ * Base props for all Archbase components that support DataSource integration
+ */
+export interface ArchbaseComponentProps<T = any, ID = any> {
+    /** DataSource for data binding (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Field name for data binding */
+    dataField?: string;
+    /** Whether the component is disabled */
+    disabled?: boolean;
+    /** Whether the component is read-only */
+    readOnly?: boolean;
+    /** Whether the field is required */
+    required?: boolean;
+    /** Custom CSS styles */
+    style?: CSSProperties;
+    /** Component size */
+    size?: MantineSize;
+    /** Component width */
+    width?: string | number;
+    /** Callback when value changes */
+    onChangeValue?: (value: any, event: any) => void;
+    /** Callback when component gains focus */
+    onFocusEnter?: FocusEventHandler<any>;
+    /** Callback when component loses focus */
+    onFocusExit?: FocusEventHandler<any>;
+    /** Reference to the underlying DOM element */
+    innerRef?: RefObject<any>;
+}
+/**
+ * Props for editor components (form inputs)
+ */
+export interface ArchbaseEditorProps<T = any, ID = any> extends ArchbaseComponentProps<T, ID> {
+    /** Current value */
+    value?: any;
+    /** Default value */
+    defaultValue?: any;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Label text */
+    label?: string;
+    /** Description text */
+    description?: string;
+    /** Error message */
+    error?: string;
+    /** Whether to show validation state */
+    withAsterisk?: boolean;
+}
+/**
+ * Props for display components
+ */
+export interface ArchbaseDisplayProps<T = any, ID = any> extends ArchbaseComponentProps<T, ID> {
+    /** Content to display */
+    children?: React.ReactNode;
+    /** Loading state */
+    loading?: boolean;
+    /** Empty state message */
+    emptyMessage?: string;
+}
+/**
+ * Event types for component interactions
+ */
+export interface ArchbaseComponentEvent<T = any> {
+    type: string;
+    data?: T;
+    target?: any;
+    originalEvent?: Event;
+}
+/**
+ * Validation result for components
+ */
+export interface ArchbaseValidationResult {
+    isValid: boolean;
+    error?: string;
+    warnings?: string[];
+}
+/**
+ * Theme configuration for components
+ */
+export interface ArchbaseThemeConfig {
+    primaryColor?: string;
+    fontFamily?: string;
+    borderRadius?: number;
+    shadows?: Record<string, string>;
+    spacing?: Record<string, number>;
+}
+/**
+ * Component configuration context
+ */
+export interface ArchbaseComponentConfig {
+    theme?: ArchbaseThemeConfig;
+    locale?: string;
+    dateFormat?: string;
+    timeFormat?: string;
+    numberFormat?: Intl.NumberFormatOptions;
+    validation?: {
+        validateOnChange?: boolean;
+        validateOnBlur?: boolean;
+        showErrorMessages?: boolean;
+    };
+}
+export type ArchbaseComponentSize = MantineSize;
+export type ArchbaseComponentVariant = 'filled' | 'outline' | 'light' | 'white' | 'default' | 'subtle';

package/dist/video/ArchbaseVideoPlayer.d.ts

@@ -0,0 +1,18 @@
+import type { ArchbaseVideoPlayerProps } from './ArchbaseVideoPlayer.types';
+/**
+ * Componente ArchbaseVideoPlayer - Player de vídeo completo
+ *
+ * @example
+ * ```tsx
+ * <ArchbaseVideoPlayer
+ *   src="/path/to/video.mp4"
+ *   poster="/path/to/poster.jpg"
+ *   controls
+ *   autoplay="muted"
+ * />
+ * ```
+ */
+export declare function ArchbaseVideoPlayer({ src, autoplay, loop, muted, volume, startTime, qualities, defaultQuality, textTracks, defaultSubtitles, controls, toolbarActions, alwaysShowControls, hideControlsOnIdle, idleTimeout, poster, width, height, fit, aspectRatio, style, className, containerClassName, accentColor, disabled, loading, error, noData, onLoadStart, onLoadedMetadata, onCanPlay, onPlay, onPause, onEnded, onTimeUpdate, onProgress, onVolumeChange, onSeeking, onSeeked, onRateChange, onQualityChange, onSubtitleToggle, onFullscreenChange, onPiPChange, onError, ariaLabel, title, playbackRates, disableClickToPlay, disableKeyboard, preload, crossOrigin, }: ArchbaseVideoPlayerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseVideoPlayer {
+    var displayName: string;
+}

package/dist/video/ArchbaseVideoPlayer.types.d.ts

@@ -0,0 +1,200 @@
+import type { CSSProperties, ReactNode } from 'react';
+/**
+ * Formatos de vídeo suportados
+ */
+export type VideoFormat = 'mp4' | 'webm' | 'ogg' | 'mov' | 'avi' | 'mkv' | 'm4v' | 'flv' | 'wmv';
+/**
+ * Source do vídeo
+ */
+export type VideoSource = string | {
+    src: string;
+    type?: string;
+} | {
+    url: string;
+} | {
+    base64: string;
+} | File | Blob;
+/**
+ * Qualidade de vídeo disponível
+ */
+export interface VideoQuality {
+    label: string;
+    src: string;
+    type?: string;
+    res?: {
+        width: number;
+        height: number;
+    };
+    bitrate?: number;
+}
+/**
+ * Faixa de legenda
+ */
+export interface TextTrack {
+    kind: 'subtitles' | 'captions' | 'descriptions' | 'chapters' | 'metadata';
+    src: string;
+    srclang: string;
+    label: string;
+    default?: boolean;
+}
+/**
+ * Estado do player
+ */
+export type PlayerState = 'idle' | 'loading' | 'ready' | 'playing' | 'paused' | 'ended' | 'error';
+/**
+ * Estado de buffer
+ */
+export interface BufferState {
+    start: number;
+    end: number;
+    length: number;
+}
+/**
+ * Ações da toolbar
+ */
+export interface VideoToolbarActions {
+    playPause?: boolean;
+    volume?: boolean;
+    fullscreen?: boolean;
+    pictureInPicture?: boolean;
+    currentTime?: boolean;
+    duration?: boolean;
+    progressBar?: boolean;
+    settings?: boolean;
+    subtitles?: boolean;
+    download?: boolean;
+}
+/**
+ * Opções de reprodução automática
+ */
+export type AutoplayBehavior = boolean | 'muted' | 'any' | 'play';
+/**
+ * Props do componente ArchbaseVideoPlayer
+ */
+export interface ArchbaseVideoPlayerProps {
+    /** Source do vídeo */
+    src: VideoSource | VideoSource[];
+    /** --- Reprodução --- */
+    /** Reproduzir automaticamente */
+    autoplay?: AutoplayBehavior;
+    /** Repetir vídeo */
+    loop?: boolean;
+    /** Mutar por padrão */
+    muted?: boolean;
+    /** Volume inicial (0-1) */
+    volume?: number;
+    /** Tempo inicial (segundos) */
+    startTime?: number;
+    /** --- Qualidade --- */
+    /** Lista de qualidades disponíveis */
+    qualities?: VideoQuality[];
+    /** Qualidade selecionada */
+    defaultQuality?: string;
+    /** --- Legendas --- */
+    /** Faixas de legendas */
+    textTracks?: TextTrack[];
+    /** Mostrar legendas por padrão */
+    defaultSubtitles?: boolean;
+    /** --- Toolbar --- */
+    /** Mostrar controles */
+    controls?: boolean;
+    /** Ações disponíveis na toolbar */
+    toolbarActions?: VideoToolbarActions | boolean;
+    /** Toolbar sempre visível */
+    alwaysShowControls?: boolean;
+    /** Esconder toolbar após inatividade */
+    hideControlsOnIdle?: boolean;
+    /** Tempo de inatividade (ms) */
+    idleTimeout?: number;
+    /** --- Pôster --- */
+    /** Imagem de capa */
+    poster?: string;
+    /** --- Layout --- */
+    /** Largura */
+    width?: string | number;
+    /** Altura */
+    height?: string | number;
+    /** Modo de ajuste */
+    fit?: 'contain' | 'cover' | 'fill' | 'none';
+    /** Aspect ratio */
+    aspectRatio?: `${number}:${number}` | '16:9' | '4:3' | '21:9';
+    /** --- Estilização --- */
+    style?: CSSProperties;
+    className?: string;
+    containerClassName?: string;
+    /** Cor de destaque (progress bar, etc) */
+    accentColor?: string;
+    /** --- Estados --- */
+    disabled?: boolean;
+    loading?: ReactNode;
+    error?: ReactNode;
+    noData?: ReactNode;
+    /** --- Eventos --- */
+    onLoadStart?: () => void;
+    onLoadedMetadata?: (metadata: {
+        duration: number;
+        width: number;
+        height: number;
+    }) => void;
+    onCanPlay?: () => void;
+    onPlay?: () => void;
+    onPause?: () => void;
+    onEnded?: () => void;
+    onTimeUpdate?: (currentTime: number, duration: number) => void;
+    onProgress?: (buffered: BufferState[]) => void;
+    onVolumeChange?: (volume: number, muted: boolean) => void;
+    onSeeking?: () => void;
+    onSeeked?: (time: number) => void;
+    onRateChange?: (rate: number) => void;
+    onQualityChange?: (quality: string) => void;
+    onSubtitleToggle?: (enabled: boolean) => void;
+    onFullscreenChange?: (isFullscreen: boolean) => void;
+    onPiPChange?: (isPiP: boolean) => void;
+    onError?: (error: MediaError | Error) => void;
+    /** --- Acessibilidade --- */
+    ariaLabel?: string;
+    title?: string;
+    /** --- Outros --- */
+    /** Velocidade de reprodução disponíveis */
+    playbackRates?: number[];
+    /** Desabilitar clique na tela para play/pause */
+    disableClickToPlay?: boolean;
+    /** Desabilitar atalhos de teclado */
+    disableKeyboard?: boolean;
+    /** Preload */
+    preload?: 'none' | 'metadata' | 'auto';
+    /** Cross origin */
+    crossOrigin?: 'anonymous' | 'use-credentials';
+}
+/**
+ * Props para sub-componentes
+ */
+export interface VideoControlsProps {
+    isPlaying: boolean;
+    isMuted: boolean;
+    volume: number;
+    currentTime: number;
+    duration: number;
+    buffered: BufferState[];
+    isFullscreen: boolean;
+    isPiP: boolean;
+    hasSubtitles: boolean;
+    subtitlesEnabled: boolean;
+    playbackRate: number;
+    onPlayPause: () => void;
+    onMuteToggle: () => void;
+    onVolumeChange: (volume: number) => void;
+    onSeek: (time: number) => void;
+    onFullscreenToggle: () => void;
+    onPiPToggle: () => void;
+    onSubtitleToggle: () => void;
+    onRateChange: (rate: number) => void;
+}
+export interface ProgressBarProps {
+    currentTime: number;
+    duration: number;
+    buffered: BufferState[];
+    onSeek: (time: number) => void;
+    accentColor?: string;
+    disabled?: boolean;
+}

package/dist/video/hooks/useVideoPlayer.d.ts

@@ -0,0 +1,58 @@
+import type { VideoSource, PlayerState, BufferState, VideoQuality, TextTrack, AutoplayBehavior } from '../ArchbaseVideoPlayer.types';
+interface UseVideoPlayerOptions {
+    src: VideoSource | VideoSource[];
+    autoplay?: AutoplayBehavior;
+    loop?: boolean;
+    muted?: boolean;
+    volume?: number;
+    startTime?: number;
+    qualities?: VideoQuality[];
+    textTracks?: TextTrack[];
+    defaultSubtitles?: boolean;
+    preload?: 'none' | 'metadata' | 'auto';
+}
+/**
+ * Hook customizado para gerenciar estado e lógica do player de vídeo
+ */
+export declare function useVideoPlayer({ src, autoplay, loop, muted, volume, startTime, qualities, textTracks, defaultSubtitles, preload, }: UseVideoPlayerOptions): {
+    videoRef: import("react").RefObject<HTMLVideoElement>;
+    containerRef: import("react").RefObject<HTMLDivElement>;
+    playerState: PlayerState;
+    isPlaying: boolean;
+    currentTime: number;
+    duration: number;
+    buffered: BufferState[];
+    volume: number;
+    muted: boolean;
+    playbackRate: number;
+    isFullscreen: boolean;
+    isPiP: boolean;
+    selectedQuality: string;
+    subtitlesEnabled: boolean;
+    sources: {
+        src: string;
+        type?: string;
+    }[];
+    play: () => void;
+    pause: () => void;
+    togglePlay: () => void;
+    seek: (time: number) => void;
+    setVolume: (vol: number) => void;
+    toggleMute: () => void;
+    setPlaybackRate: (rate: number) => void;
+    toggleFullscreen: () => void;
+    togglePiP: () => void;
+    setSelectedQuality: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setSubtitlesEnabled: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    handleLoadStart: () => void;
+    handleLoadedMetadata: () => void;
+    handleCanPlay: () => void;
+    handlePlay: () => void;
+    handlePause: () => void;
+    handleEnded: () => void;
+    handleTimeUpdate: () => void;
+    handleVolumeChange: () => void;
+    handleRateChange: () => void;
+    handleError: (e: React.SyntheticEvent<HTMLVideoElement>) => void;
+};
+export {};

package/dist/video/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ArchbaseVideoPlayer - Video Player Component
+ *
+ * Player de vídeo completo com controles customizados,
+ * suporte a múltiplas qualidades, legendas,
+ * Picture-in-Picture, e fullscreen.
+ */
+export { ArchbaseVideoPlayer } from './ArchbaseVideoPlayer';
+export { useVideoPlayer } from './hooks/useVideoPlayer';
+export type { ArchbaseVideoPlayerProps, VideoSource, VideoFormat, VideoQuality, TextTrack, PlayerState, BufferState, VideoToolbarActions, AutoplayBehavior, VideoControlsProps, ProgressBarProps, } from './ArchbaseVideoPlayer.types';

package/dist/viewers/ArchbasePDFViewer.annotations.d.ts

@@ -0,0 +1,20 @@
+import type { PDFAnnotation } from './ArchbasePDFViewer.types';
+interface ArchbasePDFAnnotationsProps {
+    annotations: PDFAnnotation[];
+    onAnnotationAdd?: (annotation: PDFAnnotation) => void;
+    onAnnotationRemove?: (annotationId: string) => void;
+    onAnnotationUpdate?: (annotationId: string, updates: Partial<PDFAnnotation>) => void;
+    disabled?: boolean;
+    pageIndex: number;
+    pageWidth: number;
+    pageHeight: number;
+}
+export declare function ArchbasePDFAnnotations({ annotations, onAnnotationAdd, onAnnotationRemove, onAnnotationUpdate, disabled, pageIndex, pageWidth, pageHeight, }: ArchbasePDFAnnotationsProps): import("react/jsx-runtime").JSX.Element;
+export interface ArchbasePDFAnnotationsListProps {
+    annotations: PDFAnnotation[];
+    onAnnotationRemove?: (annotationId: string) => void;
+    onAnnotationClick?: (annotation: PDFAnnotation) => void;
+    disabled?: boolean;
+}
+export declare function ArchbasePDFAnnotationsList({ annotations, onAnnotationRemove, onAnnotationClick, disabled, }: ArchbasePDFAnnotationsListProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/viewers/ArchbasePDFViewer.d.ts

@@ -0,0 +1,2 @@
+import type { ArchbasePDFViewerProps } from './ArchbasePDFViewer.types';
+export declare function ArchbasePDFViewer<T, ID>({ dataSource, dataField, file: fileProp, width, height, page: initialPage, scale: initialScale, rotation: initialRotation, toolbar, textLayer, renderMode, toolbarPosition, onPageChange, onZoomChange, onLoadSuccess, onLoadError, annotations, onAnnotationAdd, onAnnotationRemove, onAnnotationUpdate, enableAnnotations, showAnnotationsList, disabled, loading, error, style, className, }: ArchbasePDFViewerProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/viewers/ArchbasePDFViewer.toolbar.d.ts

@@ -0,0 +1,20 @@
+import type { PDFToolbarActions } from './ArchbasePDFViewer.types';
+interface ArchbasePDFViewerToolbarProps {
+    currentPage: number;
+    totalPages: number;
+    scale: number;
+    rotation: number;
+    toolbarActions?: PDFToolbarActions;
+    onZoomIn: () => void;
+    onZoomOut: () => void;
+    onNextPage: () => void;
+    onPreviousPage: () => void;
+    onFirstPage: () => void;
+    onLastPage: () => void;
+    onRotate: () => void;
+    onDownload?: () => void;
+    onPrint?: () => void;
+    disabled?: boolean;
+}
+export declare function ArchbasePDFViewerToolbar({ currentPage, totalPages, scale, rotation, toolbarActions, onZoomIn, onZoomOut, onNextPage, onPreviousPage, onFirstPage, onLastPage, onRotate, onDownload, onPrint, disabled, }: ArchbasePDFViewerToolbarProps): import("react/jsx-runtime").JSX.Element;
+export {};