@tekus/design-system 5.34.0 → 5.36.0

package/types/tekus-design-system-components-uploader.d.ts

@@ -0,0 +1,524 @@
+import * as _tekus_design_system_components_uploader from '@tekus/design-system/components/uploader';
+import * as _angular_core from '@angular/core';
+import { ResourceRef, Signal, ElementRef, Provider, OnDestroy, InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ProcessStep, ProcessStepsStatus } from '@tekus/design-system/components/process-steps';
+
+/**
+ * An item's lifecycle state: `idle` (no file yet) → `analyzing` (client-side
+ * preview/metadata) → `transforming` (`hooks.onTransform`) → `ready` →
+ * `queued` (waiting for `concurrencyLimit`) → `loading` (uploading, and/or
+ * `polling`) → terminal `success`/`error`/`invalid` (rejected by `restrictions`
+ * or `hooks.validate` before ever uploading).
+ */
+type UploaderStatus = 'idle' | 'analyzing' | 'transforming' | 'ready' | 'invalid' | 'queued' | 'loading' | 'success' | 'error';
+/**
+ * Stable, non-namespaced identifiers for errors raised internally by the
+ * uploader engine. Passed as-is to `UploadFlowConfig.resolveText`, if
+ * provided by the consumer, instead of an i18n-shaped key.
+ */
+type UploaderErrorCode = 'FILE_CORRUPT' | 'INVALID_FORMAT' | 'FILE_TOO_LARGE' | 'ANALYSIS_FAILED' | 'PROCESS_FAILED' | 'EXTERNAL_VALIDATION_FAILED' | 'POLLING_FAILED' | 'NO_UPLOAD_STRATEGY_CONFIGURED';
+/** Client-side-derived metadata about a file, gathered during `analyzing`. */
+interface MediaMetadata {
+    readonly width?: number;
+    readonly height?: number;
+    readonly durationMs?: number;
+    readonly aspectRatio?: number;
+    readonly mimeType?: string;
+    readonly size?: number;
+}
+/** Result of the internal preview/metadata pass (`IUploaderPreviewProvider`). */
+interface MediaAnalysis {
+    readonly previewUrl: string;
+    readonly previewBlob: Blob | undefined;
+    readonly previewBase64: string;
+    readonly metadata: MediaMetadata;
+    readonly analysisError?: boolean;
+    readonly technicalError?: string;
+    readonly errorDetail?: unknown;
+}
+/** One extension/size rule — use `FileRestrictions.rules` for per-type size limits. */
+interface RestrictionRule {
+    extensions: string[];
+    maxSizeMB?: number;
+}
+/**
+ * File-level validation, checked before anything else runs. Prefer `rules`
+ * (per-extension `maxSizeMB`) over the legacy `allowedExtensions`/`maxSizeMB`
+ * pair when different file types need different size limits — `rules` takes
+ * priority over the legacy fields when both are set.
+ */
+interface FileRestrictions {
+    rules?: RestrictionRule[];
+    maxSizeMB?: number;
+    allowedExtensions?: string[];
+}
+/** Returned by `PollingConfig.checkStatus` on every tick. */
+interface PollingResponse {
+    /** Keep returning `'loading'` to keep polling; any other value stops it. */
+    readonly status: UploaderStatus;
+    /** Overrides the item's numeric progress, if provided. */
+    readonly progress?: number;
+    /** Thrown as the item's error when `status` is `'error'` — an `UploaderErrorCode` or any string. */
+    readonly error?: string;
+    /** Overrides the item's status text — hidden by the file-card while `status` is `'loading'`. */
+    readonly statusText?: string;
+    /**
+     * When provided, `tk-uploader` renders a `tk-process-steps` for this item
+     * automatically (below its file-card) — `config.polling` is the data
+     * source, `tk-process-steps` is just how the engine shows it. Omit these
+     * for a plain `progress`/`statusText` polling flow with no step list.
+     * Only rendered while `multiple` is `false` — with `multiple` on, the
+     * uploader falls back to the plain progress bar for every item.
+     */
+    readonly steps?: ProcessStep[];
+    readonly stepsStatus?: ProcessStepsStatus;
+    readonly stepsTitle?: string;
+    readonly stepsDescription?: string;
+    /**
+     * Starts `tk-process-steps`'s own countdown once set (typically alongside
+     * a terminal `stepsStatus` like `error`) — `tk-uploader` never acts on it
+     * finishing by itself, it only emits `stepsCountdownFinished` with this
+     * item's id so the consumer decides what to do (close a modal, remove the
+     * item, show a toast, etc.).
+     */
+    readonly stepsCountdownSeconds?: number;
+    readonly stepsCountdownLabel?: string;
+}
+/** A single decoded preview frame — `url`/`blob`/`base64` of the same image. */
+interface PreviewFrame {
+    url: string;
+    blob: Blob;
+    base64: string;
+}
+/**
+ * Where a file was in its lifecycle when its remove button was clicked.
+ * `tk-uploader` never confirms or blocks removal itself — it only reports
+ * this, so the consumer can decide whether a confirmation makes sense (e.g.
+ * for `in-progress`) before calling `UploaderQueueService.removeFromQueue`.
+ */
+type UploaderRemovePhase = 'pre-upload' | 'in-progress' | 'post-upload';
+interface UploaderRemoveRequest {
+    readonly id: string;
+    readonly phase: UploaderRemovePhase;
+}
+
+/** A single file's live state in the queue — what `UploaderQueueService` tracks and updates. */
+interface UploadItem<T = unknown> {
+    id: string;
+    file: File;
+    /** 0-100. */
+    progress: number;
+    status: UploaderStatus;
+    /** Set when `status` is `'error'`/`'invalid'` — an `UploaderErrorCode` or any string. */
+    error?: string;
+    previewUrl?: string;
+    previewBlob?: Blob;
+    previewBase64?: string;
+    metadata?: MediaMetadata;
+    /** Whatever `hooks.onTransform` returned — the shape every `steps`/`multipart` function receives. */
+    payload?: T;
+    /** Internal, non-namespaced key behind `statusText` (see `UploaderQueueService`'s `STATUS_KEY_MAP`). */
+    statusKey: string;
+    /** Resolved via `config.resolveText`, if provided — hidden by the file-card while `status` is `'loading'`. */
+    statusText: string;
+    steps?: ProcessStep[];
+    stepsStatus?: ProcessStepsStatus;
+    stepsTitle?: string;
+    stepsDescription?: string;
+    stepsCountdownSeconds?: number;
+    stepsCountdownLabel?: string;
+}
+/** One state transition, recorded for every item — not currently surfaced anywhere by default. */
+interface AuditEntry {
+    itemId: string;
+    from: UploaderStatus | 'none';
+    to: UploaderStatus;
+    timestamp: number;
+    key: string;
+    errorDetail?: unknown;
+}
+/** Backing store for the queue — `UploaderStore`'s contract, injectable via `UPLOADER_STORE`. */
+interface IUploaderStore<T = unknown> {
+    readonly uploadQueue: Signal<UploadItem<T>[]>;
+    add(item: UploadItem<T>): void;
+    update(id: string, updates: Partial<UploadItem<T>>): void;
+    remove(id: string): void;
+    clear(): void;
+}
+/** Generates a client-side preview/metadata pass for a file — injectable via `UPLOADER_PREVIEW_PROVIDER`. */
+interface IUploaderPreviewProvider {
+    generatePreview(file: File): ResourceRef<MediaAnalysis | undefined>;
+}
+/**
+ * HTTP transport for the consumer's own `steps`/`multipart.uploadPart`
+ * functions — injectable via `UPLOADER_TRANSPORT`. `tk-uploader` never calls
+ * this itself; it's registered purely for the consumer's convenience.
+ */
+interface IUploaderTransport {
+    upload(url: string, file: File | Blob, method?: 'PUT' | 'POST', headers?: Record<string, string | string[]> | null, reportProgress?: boolean, observe?: 'events' | 'body', withCredentials?: boolean): Observable<unknown>;
+}
+
+/**
+ * Consumer-defined bag threaded through a single item's whole flow — every
+ * `steps`/`multipart`/`polling` function receives the same `context` object
+ * and can merge data into it for later stages to read.
+ */
+type UploadContext<C extends Record<string, unknown> = Record<string, unknown>> = C;
+/** Params passed to `MultipartConfig.init`. */
+interface InitParams<T = unknown> {
+    readonly file: File;
+    readonly payload: T | undefined;
+}
+/** Params passed to `MultipartConfig.uploadPart`. */
+interface UploadPartParams<T = unknown, C extends Record<string, unknown> = Record<string, unknown>> extends InitParams<T> {
+    readonly chunk: Blob;
+    readonly partNumber: number;
+    readonly context: UploadContext<C>;
+    readonly metadata?: MediaMetadata;
+}
+/** Params passed to `MultipartConfig.complete`. */
+interface CompleteParams<T = unknown, C extends Record<string, unknown> = Record<string, unknown>> {
+    readonly file: File;
+    readonly context: UploadContext<C>;
+    readonly payload: T | undefined;
+}
+/** Params passed to each `UploadStep` in `config.steps`. */
+interface StepParams<T = unknown, C extends Record<string, unknown> = Record<string, unknown>> {
+    readonly file: File;
+    readonly context: UploadContext<C>;
+    readonly payload: T | undefined;
+    readonly item?: UploadItem<T>;
+}
+/** Params passed to `hooks.validate`. */
+interface ValidateParams {
+    readonly file: File;
+    readonly metadata: MediaMetadata;
+}
+/** Params passed to `PollingConfig.checkStatus`. */
+interface CheckStatusParams<T = unknown, C extends Record<string, unknown> = Record<string, unknown>> {
+    readonly context: UploadContext<C>;
+    readonly payload: T | undefined;
+}
+/** Params passed to `hooks.onStepComplete`. */
+interface OnStepCompleteParams<C extends Record<string, unknown> = Record<string, unknown>> {
+    readonly stepIndex: number;
+    readonly context: UploadContext<C>;
+}
+/** Params passed to `hooks.onSuccess`. */
+interface OnSuccessParams<T = unknown, C extends Record<string, unknown> = Record<string, unknown>> {
+    readonly context: UploadContext<C>;
+    readonly payload: T | undefined;
+}
+/** Params passed to `hooks.onError`. */
+interface OnErrorParams<C extends Record<string, unknown> = Record<string, unknown>> {
+    readonly error: unknown;
+    readonly context?: UploadContext<C>;
+}
+
+/**
+ * One stage of a `config.steps` flow — run in order, one after another.
+ * Whatever it resolves to is merged into `context`, so later steps (and
+ * `hooks.onStepComplete`/`onSuccess`) can read what earlier steps put there.
+ * Used whenever `config.multipart` isn't set.
+ */
+type UploadStep<T = unknown, C extends Record<string, unknown> = Record<string, unknown>> = (params: StepParams<T, C>) => Observable<Partial<C>>;
+/** Chunked upload flow — replaces `config.steps` for large files uploaded in parts. */
+interface MultipartConfig<T = unknown, C extends Record<string, unknown> = Record<string, unknown>> {
+    /** Size of each chunk, in megabytes. */
+    readonly chunkSizeMB: number;
+    /** Starts the multipart upload; whatever it resolves to is merged into `context`. */
+    readonly init: (params: InitParams<T>) => Observable<Partial<C>>;
+    /**
+     * Uploads a single chunk. May emit a `number` (0-100 progress for that
+     * chunk) and/or a `Partial<C>` to merge into `context` — a `string` is
+     * accepted but ignored.
+     */
+    readonly uploadPart: (params: {
+        readonly file: File;
+        readonly chunk: Blob;
+        readonly partNumber: number;
+        readonly context: UploadContext<C>;
+        readonly metadata?: MediaMetadata;
+    }) => Observable<number | string | Partial<C>>;
+    /** Finalizes the multipart upload once every chunk has resolved. */
+    readonly complete: (params: {
+        readonly context: UploadContext<C>;
+        readonly payload?: T;
+    }) => Observable<boolean>;
+}
+/** Keeps asking the backend for status after the byte upload itself succeeds. */
+interface PollingConfig<T = unknown, C extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Called on every tick. See `PollingResponse` — extend the returned object
+     * with `steps`/`stepsStatus`/`stepsTitle`/`stepsDescription` to have
+     * `tk-uploader` render a `tk-process-steps` for that item automatically.
+     */
+    readonly checkStatus: (params: CheckStatusParams<T, C>) => Observable<PollingResponse>;
+    /** Milliseconds between ticks. Defaults to `UPLOADER_DEFAULTS.pollingIntervalMs`. */
+    readonly intervalMs?: number;
+}
+/** Lifecycle callbacks — the engine's only way to talk back to the consumer. */
+interface UploadHooks<T = unknown, C extends Record<string, unknown> = Record<string, unknown>> {
+    /** Fires as soon as a file is added to the queue, before validation/analysis. */
+    readonly onFileAdded?: (file: File) => void;
+    /** Extra validation beyond `restrictions` — return `false`/an error string/code to reject. */
+    readonly validate?: (params: ValidateParams) => Observable<boolean | string> | boolean | string;
+    /** Fires right before a `ready` item actually starts uploading. */
+    readonly onBeforeStart?: (file: File) => void;
+    /** Fires after each `steps` entry resolves — see `OnStepCompleteParams`. */
+    readonly onStepComplete?: (params: OnStepCompleteParams<C>) => void;
+    /** Fires once the upload (and `polling`, if configured) finishes successfully. */
+    readonly onSuccess?: (params: OnSuccessParams<T, C>) => void;
+    /**
+     * Cheap, client-side transform run after `validate` passes, before the item is
+     * queued/started. Whatever it returns becomes `item.payload` — the shape every
+     * `steps`/`multipart` function receives as `payload`.
+     */
+    readonly onTransform?: (item: UploadItem<unknown>) => Promise<T> | T;
+    /** Fires whenever a `steps`/`multipart`/`polling` observable errors. */
+    readonly onError?: (params: OnErrorParams<C>) => void;
+    /** Fires once every item in the queue has reached a terminal state. */
+    readonly onAllComplete?: () => void;
+}
+/**
+ * Everything `tk-uploader` needs to run a flow — supplied entirely by the
+ * consumer. The component itself has no business logic: validation, upload
+ * mechanics (`steps` vs `multipart`), post-upload `polling` and every
+ * lifecycle callback are all config, so the same component works for a
+ * single synchronous `POST`, a chunked multipart upload, or a long-running
+ * job that has to be polled for completion.
+ */
+interface UploadFlowConfig<T = unknown, C extends Record<string, unknown> = Record<string, unknown>> {
+    /** File-level validation, checked before anything else runs. */
+    readonly restrictions?: FileRestrictions;
+    /** Sequential upload flow — ignored if `multipart` is set. */
+    readonly steps?: UploadStep<T, C>[];
+    /** Whether `ready` items start uploading on their own, instead of waiting for a manual trigger. */
+    readonly autoStart?: Signal<boolean> | boolean;
+    /** Chunked upload flow — takes priority over `steps` when set. */
+    readonly multipart?: MultipartConfig<T, C>;
+    /** Max items allowed in `loading` at once — a throughput gate, not an admission cap (see `multiple`). */
+    readonly concurrencyLimit?: number;
+    /** Divides the 0-100 progress range across a larger choreography this flow is only part of. */
+    readonly totalSteps?: number;
+    /** Post-upload status checks — see `PollingConfig`. */
+    readonly polling?: PollingConfig<T, C>;
+    /** Lifecycle callbacks — see `UploadHooks`. */
+    readonly hooks?: UploadHooks<T, C>;
+    /**
+     * Resolves a plain `UploaderErrorCode`/status-key string into consumer-facing
+     * text — e.g. wiring it to an i18n service. Omit to surface the raw code.
+     */
+    readonly resolveText?: (key: string) => string;
+}
+
+/**
+ * Terminal "existing file" card rendered instead of the idle dropzone while
+ * the queue is empty (e.g. edit mode: an already-loaded entity) — the whole
+ * card is clickable to re-open the picker for a new version, same as any
+ * idle uploader. Purely presentational: `tk-uploader` never mutates it.
+ */
+interface LoaderPlaceholder<T> {
+    id: string | number;
+    /** Carried along unchanged — read it back from wherever this placeholder came from. */
+    payload: T;
+    title: string;
+    statusText: string;
+    status: UploaderStatus;
+    progress?: number;
+    previewUrl?: string | null;
+}
+
+/**
+ * Drag-and-drop upload zone with a queue of file cards. Fully agnostic: it
+ * has no opinion on *how* a file gets uploaded — validation, upload
+ * mechanics, post-upload polling and every lifecycle callback are supplied
+ * by the consumer through `config` (`UploadFlowConfig`). Requires
+ * `provideUploader()` in the providers of the hosting component (or a parent).
+ */
+declare class UploaderComponent<T = unknown, C extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly queueService;
+    /** Idle-state heading, shown before any file is selected. */
+    title: _angular_core.InputSignal<string>;
+    /** Whether more than one file can be added to the queue at once. */
+    multiple: _angular_core.InputSignal<boolean>;
+    /** Idle-state helper text. */
+    subtitle: _angular_core.InputSignal<string>;
+    /** Optional helper line shown below the drop zone while it's empty. */
+    helperText: _angular_core.InputSignal<string | null>;
+    /** Label for the optional link appended to `helperText`. */
+    helperLinkText: _angular_core.InputSignal<string | null>;
+    /** URL for the optional link appended to `helperText`. */
+    helperLinkUrl: _angular_core.InputSignal<string | null>;
+    /** Everything this instance needs to run its flow — see `UploadFlowConfig`. */
+    config: _angular_core.InputSignal<UploadFlowConfig<T, C>>;
+    /**
+     * Terminal "existing file" card shown instead of the idle dropzone while
+     * the queue is empty (e.g. edit mode: an already-loaded entity) — see
+     * `LoaderPlaceholder`.
+     */
+    placeholder: _angular_core.InputSignal<LoaderPlaceholder<unknown> | null>;
+    /**
+     * Ids the consumer is currently waiting on its own confirmation for (see
+     * `removeRequested`). Matching cards disable their remove button so the
+     * user can't double-trigger a request while a decision is pending — this
+     * component still has no opinion on what that confirmation looks like.
+     */
+    pendingRemovalIds: _angular_core.InputSignal<readonly string[]>;
+    /**
+     * Tooltip/accessible label for a real queue item's remove button — `tk-uploader` has no
+     * copy of its own (same reasoning as `UploadFlowConfig.resolveText`), so the button stays
+     * unlabeled unless the consumer supplies text here.
+     */
+    removeLabel: _angular_core.InputSignal<string | undefined>;
+    /** Tooltip/accessible label for the `placeholder` card's trailing (re-upload) button. */
+    placeholderReplaceLabel: _angular_core.InputSignal<string | undefined>;
+    /** Emitted with the raw `File`(s) as soon as they're picked/dropped — `File[]` when `multiple`, a single `File` otherwise. */
+    fileSelected: _angular_core.OutputEmitterRef<File | File[]>;
+    /**
+     * Emitted when a file-card's remove button is clicked — `tk-uploader` never
+     * removes the item itself. Inspect `phase` to decide whether to confirm
+     * (typically for `in-progress`) before calling
+     * `UploaderQueueService.removeFromQueue(id)`.
+     */
+    removeRequested: _angular_core.OutputEmitterRef<UploaderRemoveRequest>;
+    /**
+     * Emitted when an item's `tk-process-steps` countdown (`stepsCountdownSeconds`)
+     * reaches zero — `tk-uploader` never acts on it itself (doesn't remove the
+     * item, doesn't close anything). The consumer decides what that means: close
+     * a modal, remove the item, show a toast, etc.
+     */
+    stepsCountdownFinished: _angular_core.OutputEmitterRef<string>;
+    protected fileInput: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    protected queue: _angular_core.Signal<_tekus_design_system_components_uploader.UploadItem<unknown>[]>;
+    protected isDragging: _angular_core.WritableSignal<boolean>;
+    /**
+     * Files already in a terminal state (`success` / `error` / `invalid`) are
+     * done — they don't consume capacity anymore even though they stay visible
+     * in the queue until manually removed. Capacity is about what's still
+     * in-flight, not the size of the visible history.
+     */
+    private readonly activeCount;
+    isAtCapacity: _angular_core.Signal<boolean>;
+    /**
+     * Native `accept` attribute for the hidden `<input type="file">`, derived
+     * from `config.restrictions` (`rules[].extensions` or `allowedExtensions`)
+     * — the same list that actually validates a file — so there is a single
+     * source of truth instead of a separate, independently-settable input that
+     * could drift out of sync with it. This is only a hint for the OS file
+     * picker: it does not filter drag & drop and does not validate anything.
+     */
+    protected accept: _angular_core.Signal<string>;
+    private dragCounter;
+    onDragOver(event: DragEvent): void;
+    onDragEnter(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    onFileChange(event: Event): void;
+    onCancelItem(id: string): void;
+    protected isPendingRemoval(id: string): boolean;
+    protected stepsTitleFor(stepsTitle: string | undefined): string;
+    /** Opens the OS file picker programmatically — a no-op while `isAtCapacity()`. */
+    triggerBrowse(): void;
+    private handleFiles;
+    private emitFileSelection;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UploaderComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UploaderComponent<any, any>, "tk-uploader", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "helperLinkText": { "alias": "helperLinkText"; "required": false; "isSignal": true; }; "helperLinkUrl": { "alias": "helperLinkUrl"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "pendingRemovalIds": { "alias": "pendingRemovalIds"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "placeholderReplaceLabel": { "alias": "placeholderReplaceLabel"; "required": false; "isSignal": true; }; }, { "fileSelected": "fileSelected"; "removeRequested": "removeRequested"; "stepsCountdownFinished": "stepsCountdownFinished"; }, never, never, true, never>;
+}
+
+/**
+ * Registers every service `tk-uploader` depends on (queue, preview,
+ * transport) — add to the `providers` of the component that hosts
+ * `tk-uploader` (or a parent). Each instance gets its own queue.
+ */
+declare function provideUploader(): Provider[];
+
+/**
+ * The engine — orchestrates the whole upload flow (validation, analysis,
+ * transform, `steps`/`multipart`, `polling`, lifecycle hooks) driven purely
+ * by the `UploadFlowConfig` passed to `addToQueue`. Not `providedIn: 'root'`;
+ * `provideUploader()` gives each `tk-uploader` its own instance.
+ */
+declare class UploaderQueueService<C extends Record<string, unknown> = Record<string, unknown>> implements OnDestroy {
+    private readonly store;
+    private readonly previewProvider;
+    private readonly injector;
+    private readonly activeSubscriptions;
+    private readonly isManualTriggered;
+    private currentConfig?;
+    readonly uploadQueue: _angular_core.Signal<UploadItem<unknown>[]>;
+    /** Every state transition recorded so far — not currently surfaced anywhere by default. */
+    readonly auditHistory: _angular_core.WritableSignal<AuditEntry[]>;
+    /** Whether any item is actively `loading` right now. */
+    readonly isUploading: _angular_core.Signal<boolean>;
+    /** Whether any item is mid-flight (`analyzing`/`transforming`/`loading`) — client-side or network work in progress. */
+    readonly isBusy: _angular_core.Signal<boolean>;
+    /** `!isBusy()` — whether it's safe to close/navigate away without losing in-flight work. */
+    readonly canSafetyClose: _angular_core.Signal<boolean>;
+    ngOnDestroy(): void;
+    /**
+     * Adds one or more files to the queue and starts them through validation →
+     * analysis → transform → (auto-start or wait for `startUpload`/`startAllReady`).
+     * `config` becomes `currentConfig`, reused by every later call until the next `addToQueue`.
+     */
+    addToQueue<T = unknown>(files: File | File[], config: UploadFlowConfig<T, C>): void;
+    private runAnalysis;
+    private handleAnalysisResult;
+    private validateExternalRestrictions;
+    private runTransformation;
+    /** Manually starts a single `ready` item (when `autoStart` is `false`). */
+    startUpload(id: string): void;
+    /** Manually starts every `ready` item at once (when `autoStart` is `false`). */
+    startAllReady(): void;
+    private checkConcurrencyAndProcess;
+    private processUpload;
+    private startUploadFlow;
+    private getExecutionStream;
+    private finalizeItem;
+    private extractErrorCode;
+    private getErrorText;
+    private resolveUploaderKeyText;
+    private handleError;
+    private checkAllComplete;
+    /**
+     * Removes an item outright — revokes its preview blob URL and cancels any
+     * in-flight upload subscription first. This is outside `UploadFlowConfig`'s
+     * contract on purpose: `tk-uploader` only ever reports a removal request
+     * (see `UploaderRemoveRequest`/`removeRequested`), the consumer decides
+     * whether/when to actually call this.
+     *
+     * Deliberately does NOT cancel a still-pending `${id}_analysis` subscription:
+     * doing so would drop the analysis result (and any blob URL it already created)
+     * on the floor with nothing left to revoke it. Letting it resolve naturally lets
+     * `handleAnalysisResult`'s own "item still in the queue?" check catch it instead.
+     */
+    removeFromQueue(id: string): void;
+    private revokeItemPreview;
+    private cancelSubscription;
+    /** Cancels an item's in-flight subscription without removing it — `startUpload` resumes it. */
+    pauseUpload(id: string): void;
+    /** Revokes every preview blob URL, cancels every in-flight subscription, and empties the store. */
+    clearQueue(): void;
+    private getStatusKey;
+    private getStatusText;
+    private patchItem;
+    private addAuditEntry;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UploaderQueueService<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UploaderQueueService<any>>;
+}
+
+/** Queue backing store — provided by `provideUploader()`, actively injected by `UploaderQueueService`. */
+declare const UPLOADER_STORE: InjectionToken<IUploaderStore<unknown>>;
+/** Client-side preview/metadata generator — provided by `provideUploader()`, actively injected internally. */
+declare const UPLOADER_PREVIEW_PROVIDER: InjectionToken<IUploaderPreviewProvider>;
+/**
+ * HTTP transport — provided by `provideUploader()`, but never injected
+ * internally. Registered purely so the consumer's own `steps`/
+ * `multipart.uploadPart` functions can `inject(UPLOADER_TRANSPORT)` instead
+ * of instantiating `HttpClient` themselves.
+ */
+declare const UPLOADER_TRANSPORT: InjectionToken<IUploaderTransport>;
+
+export { UPLOADER_PREVIEW_PROVIDER, UPLOADER_STORE, UPLOADER_TRANSPORT, UploaderComponent, UploaderQueueService, provideUploader };
+export type { AuditEntry, CheckStatusParams, CompleteParams, FileRestrictions, IUploaderPreviewProvider, IUploaderStore, IUploaderTransport, InitParams, LoaderPlaceholder, MediaAnalysis, MediaMetadata, MultipartConfig, OnErrorParams, OnStepCompleteParams, OnSuccessParams, PollingConfig, PollingResponse, PreviewFrame, RestrictionRule, StepParams, UploadContext, UploadFlowConfig, UploadHooks, UploadItem, UploadPartParams, UploadStep, UploaderErrorCode, UploaderRemovePhase, UploaderRemoveRequest, UploaderStatus, ValidateParams };