@praxisui/files-upload 0.0.1

package/index.d.ts

@@ -0,0 +1,629 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, NgZone, OnInit, AfterViewInit, EventEmitter, ViewContainerRef, ChangeDetectorRef, DestroyRef, Provider } from '@angular/core';
+import { FormControl, ValidatorFn, FormGroup, FormBuilder } from '@angular/forms';
+import { ConfigStorage, ComponentDocMeta } from '@praxisui/core';
+import { SettingsPanelService, SettingsValueProvider } from '@praxisui/settings-panel';
+import { HttpClient, HttpEvent, HttpHeaders } from '@angular/common/http';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { Overlay } from '@angular/cdk/overlay';
+import { SimpleBaseInputComponent } from '@praxisui/dynamic-fields';
+import { MatSnackBar } from '@angular/material/snack-bar';
+
+interface FilesUploadConfig {
+    strategy?: 'direct' | 'presign' | 'auto';
+    ui?: {
+        showDropzone?: boolean;
+        accept?: string[];
+        dense?: boolean;
+        showConflictPolicySelector?: boolean;
+        showMetadataForm?: boolean;
+        showProgress?: boolean;
+        manualUpload?: boolean;
+        dropzone?: {
+            /** Expande a dropzone ao aproximar arquivo durante drag (desktop). */
+            expandOnDragProximity?: boolean;
+            /** Raio de proximidade, em pixels, ao redor do campo. */
+            proximityPx?: number;
+            /** Modo de expansão da zona: overlay (preferido) ou inline. */
+            expandMode?: 'overlay' | 'inline';
+            /** Altura do overlay expandido (px). */
+            expandHeight?: number;
+            /** Debounce para eventos de drag (ms). */
+            expandDebounceMs?: number;
+        };
+        list?: {
+            /** Número de itens visíveis antes de colapsar. */
+            collapseAfter?: number;
+            /** Modo de apresentação do card de detalhes. */
+            detailsMode?: 'card' | 'sidesheet' | 'auto';
+            /** Largura máxima do card (px). */
+            detailsMaxWidth?: number;
+            /** Exibir seção técnica (HTTP/logs) por padrão. */
+            detailsShowTechnical?: boolean;
+            /** Whitelist de campos de metadados a exibir (vazio = todos). */
+            detailsFields?: string[];
+            /** Âncora do overlay de detalhes. */
+            detailsAnchor?: 'item' | 'field';
+        };
+    };
+    limits?: {
+        maxFileSizeBytes?: number;
+        maxFilesPerBulk?: number;
+        maxBulkSizeBytes?: number;
+        defaultConflictPolicy?: 'ERROR' | 'SKIP' | 'OVERWRITE' | 'MAKE_UNIQUE' | 'RENAME';
+        failFast?: boolean;
+        strictValidation?: boolean;
+        maxUploadSizeMb?: number;
+    };
+    options?: {
+        allowedExtensions?: string[];
+        acceptMimeTypes?: string[];
+        targetDirectory?: string;
+        enableVirusScanning?: boolean;
+    };
+    bulk?: {
+        parallelUploads?: number;
+        retryCount?: number;
+        retryBackoffMs?: number;
+    };
+    quotas?: {
+        showQuotaWarnings?: boolean;
+        blockOnExceed?: boolean;
+    };
+    rateLimit?: {
+        autoRetryOn429?: boolean;
+        showBannerOn429?: boolean;
+        maxAutoRetry?: number;
+        baseBackoffMs?: number;
+    };
+    headers?: {
+        tenantHeader?: string;
+        userHeader?: string;
+    };
+    messages?: {
+        successSingle?: string;
+        successBulk?: string;
+        errors?: Record<string, string>;
+    };
+}
+
+/** Standard error response shape. */
+interface ErrorResponse {
+    /** Machine-readable error code (backend-defined). */
+    code: string;
+    /** Human-readable error message. */
+    message: string;
+    /** Optional details useful for debugging. */
+    details?: unknown;
+    /** Correlation identifier for tracing. */
+    traceId?: string;
+}
+
+declare enum ScanStatus {
+    PENDING = "PENDING",
+    SCANNING = "SCANNING",
+    CLEAN = "CLEAN",
+    INFECTED = "INFECTED",
+    FAILED = "FAILED"
+}
+
+/** Metadata describing an uploaded file. */
+interface FileMetadata {
+    /** Server-generated identifier. */
+    id: string;
+    /** Original filename. */
+    fileName: string;
+    /** MIME type as reported or detected. */
+    contentType: string;
+    /** Size of the file in bytes. */
+    fileSize: number;
+    /** Upload timestamp in ISO 8601 format. */
+    uploadedAt: string;
+    /** Tenant responsible for the upload. */
+    tenantId: string;
+    /** Result of antivirus scan. */
+    scanStatus: ScanStatus;
+    /** Additional metadata provided during upload. */
+    metadata?: Record<string, unknown>;
+}
+
+/** Result status for each file in a bulk upload operation. */
+declare enum BulkUploadResultStatus {
+    SUCCESS = "SUCCESS",
+    FAILED = "FAILED"
+}
+
+/** Response returned after successful single file upload. */
+interface UploadResponse {
+    file: FileMetadata;
+}
+/** Result for a single file in the bulk upload response. */
+interface BulkUploadFileResult {
+    /** Original filename. */
+    fileName: string;
+    /** Resulting status for this file. */
+    status: BulkUploadResultStatus;
+    /** Metadata returned when the file succeeds. */
+    file?: FileMetadata;
+    /** Error information when the file fails. */
+    error?: ErrorResponse;
+}
+/** Response payload for bulk upload. */
+interface BulkUploadResponse {
+    results: BulkUploadFileResult[];
+    stats: {
+        total: number;
+        succeeded: number;
+        failed: number;
+    };
+}
+
+declare enum ErrorCode {
+    INVALID_FILE_TYPE = "INVALID_FILE_TYPE",
+    FILE_TOO_LARGE = "FILE_TOO_LARGE",
+    NOT_FOUND = "NOT_FOUND",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    QUOTA_EXCEEDED = "QUOTA_EXCEEDED",
+    SEC_VIRUS_DETECTED = "SEC_VIRUS_DETECTED",
+    SEC_MALICIOUS_CONTENT = "SEC_MALICIOUS_CONTENT",
+    SEC_DANGEROUS_TYPE = "SEC_DANGEROUS_TYPE",
+    FMT_MAGIC_MISMATCH = "FMT_MAGIC_MISMATCH",
+    FMT_CORRUPTED = "FMT_CORRUPTED",
+    FMT_UNSUPPORTED = "FMT_UNSUPPORTED",
+    SYS_STORAGE_ERROR = "SYS_STORAGE_ERROR",
+    SYS_SERVICE_DOWN = "SYS_SERVICE_DOWN",
+    SYS_RATE_LIMIT = "SYS_RATE_LIMIT"
+}
+
+/** Options governing server-side upload behavior. */
+interface FileUploadOptions {
+    nameConflictPolicy: string;
+    strictValidation: boolean;
+    maxUploadSizeMb: number;
+    allowedExtensions: string[];
+    acceptMimeTypes: string[];
+    targetDirectory?: string | null;
+    enableVirusScanning: boolean;
+    customMetadata?: Record<string, unknown>;
+    failFastMode: boolean;
+}
+/** Configuration for bulk uploads. */
+interface BulkConfig {
+    failFastModeDefault: boolean;
+    maxFilesPerBatch: number;
+    maxConcurrentUploads: number;
+}
+/** Rate limiting rules. */
+interface RateLimitConfig {
+    enabled: boolean;
+    perMinute?: number;
+    perHour?: number;
+}
+/** Quota enforcement configuration. */
+interface QuotasConfig {
+    enabled: boolean;
+    tenantMaxPerDay?: number;
+    userMaxPerDay?: number;
+}
+/** Map of server-provided message codes to friendly messages. */
+type ServerMessages = Record<string, string>;
+/** Additional metadata returned by the server. */
+interface Metadata {
+    version: string;
+    locale: string;
+}
+/** Effective upload configuration provided by the backend. */
+interface EffectiveUploadConfig {
+    options: FileUploadOptions;
+    bulk: BulkConfig;
+    rateLimit: RateLimitConfig;
+    quotas: QuotasConfig;
+    messages: ServerMessages;
+    metadata: Metadata;
+}
+
+interface PresignResponse {
+    uploadUrl: string;
+    headers?: Record<string, string>;
+    fields?: Record<string, string>;
+}
+/**
+ * Options for a single file upload.
+ */
+interface UploadOptions {
+    /** Backend options JSON (FileUploadOptionsRecord), enviado no campo 'options'. */
+    optionsJson?: string;
+    /** Metadados por arquivo (serializado em 'metadata'). */
+    metadata?: Record<string, unknown>;
+    /** Política de conflito (serializada em 'conflictPolicy'). */
+    conflictPolicy?: string;
+    /** Número de tentativas de retry. */
+    retryCount?: number;
+}
+/**
+ * Represents a file for bulk uploads.
+ */
+interface BulkUploadFile {
+    file: File;
+    metadata?: Record<string, unknown>;
+    conflictPolicy?: string;
+}
+/**
+ * Options applied to a bulk upload request.
+ */
+interface BulkUploadOptions {
+    /** Backend options JSON (FileUploadOptionsRecord), enviado no campo 'options'. */
+    optionsJson?: string;
+    /** failFast (alias de failFastMode) conforme backend. */
+    failFast?: boolean;
+    /** failFastMode legado. */
+    failFastMode?: boolean;
+    /** Número de tentativas de retry. */
+    retryCount?: number;
+}
+declare class FilesApiClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Upload a single file com metadata/conflictPolicy (compat) e/ou options JSON.
+     */
+    upload(baseUrl: string, file: File, options?: UploadOptions): Observable<HttpEvent<unknown>>;
+    /**
+     * Upload múltiplo com arrays de metadata/conflictPolicy (compat) e/ou options JSON.
+     */
+    bulkUpload(baseUrl: string, files: BulkUploadFile[], options?: BulkUploadOptions): Observable<HttpEvent<unknown>>;
+    presign(baseUrl: string, fileName: string): Observable<PresignResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilesApiClient, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilesApiClient>;
+}
+
+declare class PresignedUploaderService {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Uploads a file to a presigned URL and retries when configured.
+     */
+    upload(target: PresignResponse, file: File, retryCount?: number): Observable<HttpEvent<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PresignedUploaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PresignedUploaderService>;
+}
+
+interface RateLimitInfo {
+    limit: number;
+    remaining: number;
+    resetEpochSeconds: number;
+}
+interface MappedError {
+    message: string;
+    rateLimit?: RateLimitInfo;
+    title?: string;
+    severity?: 'info' | 'warn' | 'error';
+    category?: string;
+    phase?: string;
+    userAction?: string;
+}
+interface TranslateLike {
+    instant(key: string): string;
+}
+declare const TRANSLATE_LIKE: InjectionToken<TranslateLike>;
+declare const FILES_UPLOAD_ERROR_MESSAGES: InjectionToken<Partial<Record<string, string>>>;
+declare class ErrorMapperService {
+    private readonly customMessages?;
+    private readonly translate?;
+    constructor(customMessages?: Partial<Record<string, string>> | undefined, translate?: TranslateLike | undefined);
+    map(error: ErrorResponse, headers?: HttpHeaders): MappedError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorMapperService, [{ optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorMapperService>;
+}
+
+interface FilesUploadTexts {
+    settingsAriaLabel: string;
+    dropzoneLabel: string;
+    dropzoneButton: string;
+    conflictPolicyLabel: string;
+    metadataLabel: string;
+    progressAriaLabel: string;
+    rateLimitBanner: string;
+}
+declare const FILES_UPLOAD_TEXTS: InjectionToken<FilesUploadTexts>;
+
+interface DragPointer {
+    x: number;
+    y: number;
+}
+declare class DragProximityService implements OnDestroy {
+    private zone;
+    private draggingWithFiles$;
+    private pointer$;
+    private dragCounter;
+    constructor(zone: NgZone);
+    ngOnDestroy(): void;
+    isDraggingWithFiles(): Observable<boolean>;
+    pointer(): Observable<DragPointer>;
+    withinProximity(rect: DOMRect, proximityPx: number, pt?: DragPointer | null): boolean;
+    private onDragEnter;
+    private onDragLeave;
+    private onDragOver;
+    private onDrop;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragProximityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragProximityService>;
+}
+
+declare class PraxisFilesUpload implements OnInit, AfterViewInit, OnDestroy {
+    private settingsPanel;
+    private dragProx;
+    private defaultTexts;
+    private overlay;
+    private viewContainerRef;
+    private cdr;
+    private api?;
+    private presign?;
+    private errors?;
+    private translate?;
+    private configStorage?;
+    config: FilesUploadConfig | null;
+    componentId: string;
+    baseUrl?: string;
+    displayMode: 'full' | 'compact';
+    uploadSuccess: EventEmitter<{
+        file: FileMetadata;
+    }>;
+    bulkComplete: EventEmitter<BulkUploadResponse>;
+    error: EventEmitter<ErrorResponse>;
+    rateLimited: EventEmitter<RateLimitInfo>;
+    retry: EventEmitter<BulkUploadFileResult>;
+    download: EventEmitter<BulkUploadFileResult>;
+    copyLink: EventEmitter<BulkUploadFileResult>;
+    detailsOpened: EventEmitter<BulkUploadFileResult>;
+    detailsClosed: EventEmitter<BulkUploadFileResult>;
+    pendingFilesChange: EventEmitter<File[]>;
+    proximityChange: EventEmitter<boolean>;
+    private fileInput?;
+    private hostRef?;
+    private overlayTmpl?;
+    private selectedOverlayTmpl?;
+    conflictPolicies: Array<'ERROR' | 'SKIP' | 'OVERWRITE' | 'MAKE_UNIQUE' | 'RENAME'>;
+    conflictPolicy: FormControl<string | null>;
+    uploadProgress: number;
+    allowMultiple: boolean;
+    rateLimit: RateLimitInfo | null;
+    quotaExceeded: boolean;
+    errorMessage: string;
+    acceptString: string;
+    metadata: FormControl<string | null>;
+    uploadedFiles: Array<{
+        fileName: string;
+        success: boolean;
+    }>;
+    texts: FilesUploadTexts;
+    lastResults: BulkUploadFileResult[] | null;
+    lastStats: {
+        total: number;
+        succeeded: number;
+        failed: number;
+    } | null;
+    BulkUploadResultStatus: typeof BulkUploadResultStatus;
+    private uploading;
+    isDragging: boolean;
+    private currentFiles;
+    private serverEffective?;
+    showProximityOverlay: boolean;
+    private proxSub?;
+    private proxPtrSub?;
+    private hostRect?;
+    private draggingFiles;
+    private overlayRef?;
+    private escListener;
+    private windowDropListener;
+    private windowDragEndListener;
+    private selectedOverlayRef?;
+    showAllResults: boolean;
+    constructor(settingsPanel: SettingsPanelService, dragProx: DragProximityService, defaultTexts: FilesUploadTexts, overlay: Overlay, viewContainerRef: ViewContainerRef, cdr: ChangeDetectorRef, api?: FilesApiClient | undefined, presign?: PresignedUploaderService | undefined, errors?: ErrorMapperService | undefined, translate?: TranslateLike | undefined, configStorage?: ConfigStorage | undefined);
+    get showProgress(): boolean;
+    get isUploading(): boolean;
+    get hasUploadedFiles(): boolean;
+    get pendingFiles(): File[];
+    get pendingCount(): number;
+    get hasLastResults(): boolean;
+    openFile(input: HTMLInputElement): void;
+    triggerSelect(): void;
+    displayFileName(f: any): string;
+    formatBytes(bytes: number | undefined | null): string;
+    mapErrorFull(err: unknown): any;
+    get metadataError(): string | null;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private updateHostRect;
+    private evalProximity;
+    private manageOverlay;
+    private ensureOverlay;
+    private syncOverlayGeometry;
+    private disposeOverlay;
+    private manageSelectedOverlay;
+    private ensureSelectedOverlay;
+    private syncSelectedOverlayGeometry;
+    private hideSelectedOverlay;
+    private disposeSelectedOverlay;
+    private hideProximityOverlay;
+    private resolveTexts;
+    t(key: string, fallback: string): string;
+    openSettings(): void;
+    private applyConfig;
+    private loadLocalConfig;
+    private saveLocalConfig;
+    onDragOver(evt: DragEvent): void;
+    onDragLeave(_evt: DragEvent): void;
+    onDrop(evt: DragEvent): void;
+    onFilesSelected(evt: Event): void;
+    triggerUpload(): void;
+    clearSelection(): void;
+    removePendingFile(file: File): void;
+    private startUpload;
+    private directUpload;
+    private buildOptionsJson;
+    private handleProgress;
+    private handleError;
+    private finishUpload;
+    get visibleResults(): BulkUploadFileResult[];
+    private fileToBulkUploadFileResult;
+    onRetry(file: File | BulkUploadFileResult): void;
+    onDownload(file: File | BulkUploadFileResult): void;
+    onCopyLink(file: File | BulkUploadFileResult): void;
+    removeResult(item: BulkUploadFileResult): void;
+    toggleDetailsFor(item: BulkUploadFileResult): void;
+    onDetailsToggle(ev: Event, item: BulkUploadFileResult): void;
+    private validateFiles;
+    get policiesSummary(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisFilesUpload, [null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisFilesUpload, "praxis-files-upload", never, { "config": { "alias": "config"; "required": false; }; "componentId": { "alias": "componentId"; "required": false; }; "baseUrl": { "alias": "baseUrl"; "required": false; }; "displayMode": { "alias": "displayMode"; "required": false; }; }, { "uploadSuccess": "uploadSuccess"; "bulkComplete": "bulkComplete"; "error": "error"; "rateLimited": "rateLimited"; "retry": "retry"; "download": "download"; "copyLink": "copyLink"; "detailsOpened": "detailsOpened"; "detailsClosed": "detailsClosed"; "pendingFilesChange": "pendingFilesChange"; "proximityChange": "proximityChange"; }, never, ["*"], true, never>;
+}
+
+declare class PdxFilesUploadFieldComponent extends SimpleBaseInputComponent {
+    config: FilesUploadConfig | null;
+    valueMode: 'metadata' | 'id';
+    baseUrl?: string;
+    uploadError: string | null;
+    private uploader?;
+    pendingFiles: File[];
+    onTriggerUpload(): void;
+    onClearSelection(): void;
+    handlePendingFiles(files: File[]): void;
+    lastFileName: string | null;
+    batchCount: number;
+    isProximityActive: boolean;
+    private readonly errors;
+    private readonly translate;
+    get showUploadError(): boolean;
+    t(key: string, fallback: string): string;
+    onUploadSuccess(event: {
+        file: FileMetadata;
+    }): void;
+    onBulkComplete(resp: BulkUploadResponse): void;
+    onUploadError(event: unknown): void;
+    isShellDisabled(): boolean;
+    onProximityChange(isActive: boolean): void;
+    openFromShell(): void;
+    onOpenInfo(): void;
+    onOpenMenu(): void;
+    onClear(): void;
+    get policySummary(): string;
+    onRemovePendingFile(file: File, event: MouseEvent): void;
+    formatBytes(bytes: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PdxFilesUploadFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PdxFilesUploadFieldComponent, "pdx-material-files-upload", never, { "config": { "alias": "config"; "required": false; }; "valueMode": { "alias": "valueMode"; "required": false; }; "baseUrl": { "alias": "baseUrl"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare function acceptValidator(allowed: string[]): ValidatorFn;
+declare function maxFileSizeValidator(maxBytes: number): ValidatorFn;
+declare function maxFilesPerBulkValidator(maxFiles: number): ValidatorFn;
+declare function maxBulkSizeValidator(maxBytes: number): ValidatorFn;
+
+declare class PraxisFilesUploadConfigEditor implements OnInit, SettingsValueProvider {
+    private fb;
+    private panelData;
+    private snackBar;
+    private destroyRef;
+    form: FormGroup;
+    baseUrl?: string;
+    private state;
+    serverLoading: () => boolean;
+    serverData: () => EffectiveUploadConfig | undefined;
+    serverError: () => unknown;
+    get uiGroup(): FormGroup;
+    get dropzoneGroup(): FormGroup;
+    get listGroup(): FormGroup;
+    get limitsGroup(): FormGroup;
+    get optionsGroup(): FormGroup;
+    get quotasGroup(): FormGroup;
+    get rateLimitGroup(): FormGroup;
+    get bulkGroup(): FormGroup;
+    get messagesGroup(): FormGroup;
+    get headersGroup(): FormGroup;
+    get errorsGroup(): FormGroup;
+    errorCodes: ErrorCode[];
+    errorEntries: Array<{
+        code: string;
+        label: string;
+    }>;
+    isDirty$: BehaviorSubject<boolean>;
+    isValid$: Observable<boolean>;
+    isBusy$: BehaviorSubject<boolean>;
+    jsonError: string | null;
+    constructor(fb: FormBuilder, panelData: any, snackBar: MatSnackBar, destroyRef: DestroyRef);
+    ngOnInit(): void;
+    private applyServerConfig;
+    getSettingsValue(): FilesUploadConfig;
+    copyServerConfig(): void;
+    onJsonChange(json: string): void;
+    private getHeadersForFetch;
+    refetchServerConfig(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisFilesUploadConfigEditor, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisFilesUploadConfigEditor, "praxis-files-upload-config-editor", never, {}, {}, never, never, true, never>;
+}
+
+declare const FILES_UPLOAD_PT_BR: {
+    'praxis.filesUpload.settingsAriaLabel': string;
+    'praxis.filesUpload.dropzoneLabel': string;
+    'praxis.filesUpload.dropzoneButton': string;
+    'praxis.filesUpload.conflictPolicyLabel': string;
+    'praxis.filesUpload.metadataLabel': string;
+    'praxis.filesUpload.progressAriaLabel': string;
+    'praxis.filesUpload.rateLimitBanner': string;
+    'praxis.filesUpload.settingsTitle': string;
+    'praxis.filesUpload.statusSuccess': string;
+    'praxis.filesUpload.statusError': string;
+    'praxis.filesUpload.invalidMetadata': string;
+    'praxis.filesUpload.genericUploadError': string;
+    'praxis.filesUpload.acceptError': string;
+    'praxis.filesUpload.maxFileSizeError': string;
+    'praxis.filesUpload.maxFilesPerBulkError': string;
+    'praxis.filesUpload.maxBulkSizeError': string;
+    'praxis.filesUpload.errors.INVALID_FILE_TYPE': string;
+    'praxis.filesUpload.errors.FILE_TOO_LARGE': string;
+    'praxis.filesUpload.errors.NOT_FOUND': string;
+    'praxis.filesUpload.errors.UNAUTHORIZED': string;
+    'praxis.filesUpload.errors.RATE_LIMIT_EXCEEDED': string;
+    'praxis.filesUpload.errors.INTERNAL_ERROR': string;
+    'praxis.filesUpload.errors.QUOTA_EXCEEDED': string;
+    'praxis.filesUpload.errors.SEC_VIRUS_DETECTED': string;
+    'praxis.filesUpload.errors.SEC_MALICIOUS_CONTENT': string;
+    'praxis.filesUpload.errors.SEC_DANGEROUS_TYPE': string;
+    'praxis.filesUpload.errors.FMT_MAGIC_MISMATCH': string;
+    'praxis.filesUpload.errors.FMT_CORRUPTED': string;
+    'praxis.filesUpload.errors.FMT_UNSUPPORTED': string;
+    'praxis.filesUpload.errors.SYS_STORAGE_ERROR': string;
+    'praxis.filesUpload.errors.SYS_SERVICE_DOWN': string;
+    'praxis.filesUpload.errors.SYS_RATE_LIMIT': string;
+    'praxis.filesUpload.errors.ARQUIVO_MUITO_GRANDE': string;
+    'praxis.filesUpload.errors.TIPO_ARQUIVO_INVALIDO': string;
+    'praxis.filesUpload.errors.TIPO_MIDIA_NAO_SUPORTADO': string;
+    'praxis.filesUpload.errors.CAMPO_OBRIGATORIO_AUSENTE': string;
+    'praxis.filesUpload.errors.OPCOES_JSON_INVALIDAS': string;
+    'praxis.filesUpload.errors.ARGUMENTO_INVALIDO': string;
+    'praxis.filesUpload.errors.NAO_AUTORIZADO': string;
+    'praxis.filesUpload.errors.ERRO_INTERNO': string;
+    'praxis.filesUpload.errors.LIMITE_TAXA_EXCEDIDO': string;
+    'praxis.filesUpload.errors.COTA_EXCEDIDA': string;
+    'praxis.filesUpload.errors.ARQUIVO_JA_EXISTE': string;
+    'praxis.filesUpload.errors.INVALID_JSON_OPTIONS': string;
+    'praxis.filesUpload.errors.EMPTY_FILENAME': string;
+    'praxis.filesUpload.errors.FILE_EXISTS': string;
+    'praxis.filesUpload.errors.PATH_TRAVERSAL': string;
+    'praxis.filesUpload.errors.INSUFFICIENT_STORAGE': string;
+    'praxis.filesUpload.errors.UPLOAD_TIMEOUT': string;
+    'praxis.filesUpload.errors.BULK_UPLOAD_TIMEOUT': string;
+    'praxis.filesUpload.errors.BULK_UPLOAD_CANCELLED': string;
+    'praxis.filesUpload.errors.USER_CANCELLED': string;
+    'praxis.filesUpload.errors.UNKNOWN_ERROR': string;
+};
+
+/** Metadata for PraxisFilesUpload component */
+declare const PRAXIS_FILES_UPLOAD_COMPONENT_METADATA: ComponentDocMeta;
+/** Provider para auto-registrar metadados do componente Files Upload. */
+declare function providePraxisFilesUploadMetadata(): Provider;
+
+export { BulkUploadResultStatus, ErrorCode, ErrorMapperService, FILES_UPLOAD_ERROR_MESSAGES, FILES_UPLOAD_PT_BR, FILES_UPLOAD_TEXTS, FilesApiClient, PRAXIS_FILES_UPLOAD_COMPONENT_METADATA, PdxFilesUploadFieldComponent, PraxisFilesUpload, PraxisFilesUploadConfigEditor, PresignedUploaderService, ScanStatus, TRANSLATE_LIKE, acceptValidator, maxBulkSizeValidator, maxFileSizeValidator, maxFilesPerBulkValidator, providePraxisFilesUploadMetadata };
+export type { BulkConfig, BulkUploadFile, BulkUploadFileResult, BulkUploadOptions, BulkUploadResponse, EffectiveUploadConfig, ErrorResponse, FileMetadata, FileUploadOptions, FilesUploadConfig, FilesUploadTexts, MappedError, Metadata, PresignResponse, QuotasConfig, RateLimitConfig, RateLimitInfo, ServerMessages, TranslateLike, UploadOptions, UploadResponse };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@praxisui/files-upload",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^20.0.0",
+    "@angular/core": "^20.0.0",
+    "@angular/material": "^20.0.0",
+    "@ngx-translate/core": "^17.0.0",
+    "@praxisui/settings-panel": "^0.0.1"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codexrodrigues/praxis"
+  },
+  "homepage": "https://github.com/codexrodrigues/praxis#readme",
+  "bugs": {
+    "url": "https://github.com/codexrodrigues/praxis/issues"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/praxisui-files-upload.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/praxisui-files-upload.mjs"
+    }
+  }
+}