@embedpdf/angular 3.0.0-next.13 → 3.0.0-next.15

package/dist/annotation/index.d.ts

@@ -0,0 +1,599 @@
+import * as _embedpdf_plugin_annotation from '@embedpdf/plugin-annotation';
+import { Annotation, AnnotationSelectionApi, AnnotationProperties, AnnotationDraftApi, AnnotationTextApi, AnnotationToolsApi, ToolDefaults, ToolDefaultsChangedEvent, AnnotationStampsApi, AnnotationLinksApi, AnnotationFilter, AnnotationRef, AnnotationAnchor, AnnotationConfig, CommentThread, AnnotationCapability, CommentsApi, CommentThreadChangedEvent, FilePickerProvider, AnnotationSubtype, HandleRole, AnnotationRotationAnchor, TextItem, CreationDraft } from '@embedpdf/plugin-annotation';
+export * from '@embedpdf/plugin-annotation';
+import * as _embedpdf_core_annotation from '@embedpdf/core-annotation';
+import { RenderItem, Point } from '@embedpdf/core-annotation';
+export { AnnotationFlags, CreationDraftAnchor, FieldValues, LineEnding, LineEndings, RenderItem, Style, TextAlign, TextStyle } from '@embedpdf/core-annotation';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature, EpdfPluginService, EpdfPageContext } from '@embedpdf/angular/runtime';
+import * as _embedpdf_core from '@embedpdf/core';
+import * as i0 from '@angular/core';
+import { Signal, TemplateRef, Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as _embedpdf_web from '@embedpdf/web';
+import { FramePixels, PictureOrPainting, TextBoxStyle } from '@embedpdf/web';
+import { AnchoredPlacement, EpdfAnchor } from '@embedpdf/angular/anchored';
+
+/** `annotation.selection`: what is selected, the verbs that change it as one, and its style panel. */
+interface EpdfAnnotationSelection extends AnnotationSelectionApi {
+    /**
+     * What a style panel shows for the selection: `{ properties, values, mixed }`, the same as
+     * `getProperties()` but as a signal, so the panel follows the selection and its changes.
+     * Empty with nothing selected, and without a document.
+     */
+    readonly properties: Signal<AnnotationProperties>;
+}
+/** `annotation.tools`: the tools and their defaults, with the reads a picker follows. */
+interface EpdfAnnotationTools extends Omit<AnnotationToolsApi, 'onDefaultsChanged'> {
+    /**
+     * A tool's defaults, the fields its next annotation starts with, as a signal: a color picker
+     * bound to it always shows the current color. Pass the id, or a function that reads it.
+     * Empty without a document.
+     */
+    defaultsOf(id: string | (() => string)): Signal<ToolDefaults>;
+    /**
+     * What a style panel for a tool shows (`{ properties, values, mixed }`), as a signal. Pass the
+     * id, or a function that reads it. Empty without a document.
+     */
+    propertiesOf(id: string | (() => string)): Signal<AnnotationProperties>;
+    /** A tool's defaults changed, from your UI or your code: `toolId`, `defaults`. */
+    readonly defaultsChanged$: Observable<ToolDefaultsChangedEvent>;
+}
+declare const EpdfAnnotation_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_annotation.AnnotationCapability, {
+    status: _embedpdf_core.ResourceStatus;
+    selected: readonly Annotation[];
+    hovered: Annotation | null;
+    editing: Annotation | null;
+}, "create" | "get" | "cancel" | "delete" | "list" | "getAt" | "isPending" | "getStatus" | "getHovered" | "refresh" | "createFromSelection" | "update" | "reorder" | "export" | "import" | "downloadResource" | "setFilePickerProvider" | "canRead" | "canCreate" | "canUpdate" | "canDelete", "onCreated" | "onUpdated" | "onDeleted" | "onReordered" | "onResynced" | "onWriteFailed" | "onSelectionChanged" | "onDraftChanged" | "onEditingChanged" | "onHoverChanged">;
+/**
+ * Annotations: `create()`, `update()`, `delete()` and the rest of the Methods tables, the
+ * selecting page's State table as signals (`annotation.selected()`), the parts the capability
+ * has (`annotation.selection.set(refs)`, `annotation.tools.updateDefaults(id, changes)`), its
+ * events as streams (`annotation.created$`), and its settings (`annotation.settings()`,
+ * `annotation.updateSettings({ chrome })`). Comments have their own service, `EpdfComments`.
+ *
+ * Without a document the signals read empty and the methods refuse with `not-ready`. The checks
+ * (`canCreate()`, `canDelete(ref)`, `selection.canGroup()`, `stamps.isArmed()`) are state:
+ * read in a template, they follow the document, its permissions and the selection.
+ */
+declare class EpdfAnnotation extends EpdfAnnotation_base {
+    /** The same capability, typed with the reads only framework code has (an annotation's anchor). */
+    private readonly host;
+    /** The selection: `set(refs)`, `update(changes)`, `delete()`, … and `properties()`. */
+    readonly selection: EpdfAnnotationSelection;
+    /** A polygon or polyline being drawn: `get()`, `finish()`, `cancel()`. */
+    readonly draft: AnnotationDraftApi;
+    /** Typing in a text box: `begin(ref)`, `end()`, `getEditing()`, `toggleFormat(format)`. */
+    readonly text: AnnotationTextApi;
+    /** The tools: `list()`, `register(tool)`, `updateDefaults(id, changes)`, `defaultsOf(id)`, … */
+    readonly tools: EpdfAnnotationTools;
+    /** Stamps from bytes: `arm(stamp)`, `disarm()`, `isArmed()`, `place(stamp, placement)`. */
+    readonly stamps: AnnotationStampsApi;
+    /** An annotation's link: `get(ref)`, `set(ref, target)`, `clear(ref)`. */
+    readonly links: AnnotationLinksApi;
+    /**
+     * The annotations matching `filter` (some pages, one kind), in drawing order, as the user sees
+     * them: a signal that keeps the same array while they stay the same. Pass the filter, or a
+     * function that reads it (`() => ({ pages: [this.page()] })`). Empty without a document.
+     * Call it once, in a field or the constructor, and read the signal in your template.
+     */
+    watch(filter?: AnnotationFilter | null | (() => AnnotationFilter | null | undefined)): Signal<readonly Annotation[]>;
+    /**
+     * An anchor for `<epdf-anchored>` that keeps a card or a badge on one annotation: its page and
+     * the box around what it shows, following a move as it happens. Pass the ref, or a function
+     * that reads it (`() => this.hovered()?.ref ?? null`). Null for null, or an annotation that
+     * isn't here. It changes when the annotation moves, not while people scroll or zoom.
+     */
+    anchorOf(ref: AnnotationRef | null | (() => AnnotationRef | null | undefined)): Signal<AnnotationAnchor | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfAnnotation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfAnnotation>;
+}
+/**
+ * The annotation plugin: drawing, selecting, changing and saving annotations, and comments. It
+ * works with the interaction plugin, so give `withInteraction()` too, and an
+ * `<epdf-annotation-layer>` in each page:
+ * `provideEmbedPdf({ engine }, withStage(), withRender(), withInteraction(), withAnnotation())`.
+ */
+declare function withAnnotation(options?: AnnotationConfig): EmbedPdfFeature;
+
+/**
+ * Comments and replies, as their own service: `inject(EpdfComments)`. A comments sidebar needs
+ * the threads and the verbs on them, not the rest of the annotation API, so they get a service
+ * of their own (React's `useComments()` and `useCommentThreads()`). `withAnnotation()` provides
+ * it.
+ *
+ * The threads come with where their page is shown (`pageIndex`, `pageLabel`): the join of the
+ * plugin's threads and the document's page list is `@embedpdf/web`'s, the same for every
+ * framework.
+ */
+
+/**
+ * A comment thread with where its page is shown now. Its identity stays `page`, like every
+ * annotation's; these two fields are for showing it, and follow page moves and deletes.
+ */
+interface CommentThreadView extends CommentThread {
+    /** The page's place in the document, from 0; `-1` for the moment after its page is deleted. */
+    pageIndex: number;
+    /**
+     * The page's label when the PDF has one (`'iv'`, `'A-2'`), else its number from 1, as a
+     * string: print it as it is.
+     */
+    pageLabel: string;
+}
+/**
+ * The comments of the document in scope (`[epdfDocumentScope]`), else the active one: every
+ * thread as `threads()`, one as `threadOf(ref)`, the verbs (`reply()`, `setText()`,
+ * `setStatus()`, `setMarked()`, `delete()`, `deleteThread()`), the checks (`canReply(ref)`, …),
+ * which follow the document and its permissions in a template, and `threadChanged$`. Without a
+ * document the threads are empty and the verbs refuse with `not-ready`.
+ */
+declare class EpdfComments extends EpdfPluginService<AnnotationCapability> {
+    constructor();
+    /** Every thread, in reading order, read once. In a template, use `threads()`. */
+    readonly listThreads: CommentsApi['listThreads'];
+    /** The thread a comment is in (its first comment, a reply or a review state), read once, or null. */
+    readonly getThread: CommentsApi['getThread'];
+    /** Reply to the thread's first comment, whichever comment you pass. Resolves `{ annotation }`. */
+    readonly reply: CommentsApi['reply'];
+    /** Change a comment's text. */
+    readonly setText: CommentsApi['setText'];
+    /** Set the user's review state on a thread, such as `'accepted'`. */
+    readonly setStatus: CommentsApi['setStatus'];
+    /** Check a thread off for the user, or clear the check mark. */
+    readonly setMarked: CommentsApi['setMarked'];
+    /** Delete a comment with its replies; the first comment of a thread deletes the thread. */
+    readonly delete: CommentsApi['delete'];
+    /** Delete a whole thread, all of it or none. Resolves `{ deleted, failed }`. */
+    readonly deleteThread: CommentsApi['deleteThread'];
+    /** Whether the user may reply to this thread. */
+    readonly canReply: CommentsApi['canReply'];
+    /** Whether the user may change this comment's text. */
+    readonly canSetText: CommentsApi['canSetText'];
+    /** Whether the user may set a review state on this thread. */
+    readonly canSetStatus: CommentsApi['canSetStatus'];
+    /** Whether the user may check this thread off. */
+    readonly canSetMarked: CommentsApi['canSetMarked'];
+    /** Whether the user may delete this comment. */
+    readonly canDelete: CommentsApi['canDelete'];
+    /** Whether the user may delete every comment in this thread. */
+    readonly canDeleteThread: CommentsApi['canDeleteThread'];
+    /** A thread changed through this viewer: a reply, a text, a review state, a check mark or a delete. */
+    readonly threadChanged$: Observable<CommentThreadChangedEvent>;
+    private readonly scope;
+    private readonly rawThreads;
+    /** The pages of this service's document: a page moved or deleted moves its threads' labels. */
+    private readonly pages;
+    /**
+     * Every thread in the document, in reading order (by page, then from the top), each with its
+     * page's `pageIndex` and `pageLabel`. Own, remote and reloaded changes all show. The same
+     * array until a thread or a page changes; empty without a document.
+     */
+    readonly threads: Signal<readonly CommentThreadView[]>;
+    /**
+     * The thread a comment is in, whether you pass its first comment, a reply or a review state,
+     * with its page's label; null for null, or a comment in no thread. Pass the ref, or a function
+     * that reads it (`() => this.note().ref`).
+     */
+    threadOf(ref: AnnotationRef | null | (() => AnnotationRef | null | undefined)): Signal<CommentThreadView | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfComments, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfComments>;
+}
+
+/**
+ * The browser's file dialog, filtered by the tool's `accept`: what `withFilePicker()` installs
+ * when you give it nothing. A picked `File` carries its own name and type.
+ */
+declare const filePickerProvider: FilePickerProvider;
+/**
+ * The file dialog behind every click-then-pick tool, for every document the viewer opens.
+ * Without an argument it is the browser's dialog ({@link filePickerProvider}); pass your own
+ * function to pick from your library (it gets the tool, the page and the point, and returns the
+ * file or `null` to cancel), or `null` to make those tools do nothing.
+ */
+declare function withFilePicker(provider?: FilePickerProvider | null): EmbedPdfFeature;
+
+/** The box a look draws into: the size to draw at, how it's turned, and how it's scaled. */
+interface AnnotationFrame {
+    /** Its width in pixels at the annotation's 100% size, before its turn: draw at this. */
+    readonly width: number;
+    /** Its height in pixels at the annotation's 100% size, before its turn: draw at this. */
+    readonly height: number;
+    /**
+     * How it's turned on screen, degrees clockwise: the page's turn and the annotation's own. 0 is
+     * upright; turn your content by `-rotation` to keep it upright.
+     */
+    readonly rotation: number;
+    /**
+     * How much the layer scales what you draw, with the page: the zoom, or for an annotation that
+     * keeps its size on screen, the zoom up to 1.
+     */
+    readonly scale: number;
+}
+/** What an `epdfAnnotationInteractive` function is asked: the annotation, and the active tool. */
+interface AnnotationInteractiveContext {
+    readonly annotation: Annotation;
+    readonly toolId: string;
+}
+/**
+ * What a look's template gets. `let-annotation` is the annotation; the rest are named:
+ * `let-frame="frame"`, `let-hovered="hovered"`, `let-native="native"`.
+ */
+interface EpdfAnnotationTemplateContext {
+    /** The annotation, as `get()` returns it. */
+    $implicit: Annotation;
+    /** The same annotation, by name. */
+    annotation: Annotation;
+    /**
+     * The box you draw into. The layer places, turns and scales it like the annotation's own
+     * drawing, also during a drag, a resize or a turn. Fill it (`width: 100%; height: 100%`) and
+     * draw at the annotation's 100% size: your text and borders scale with the page.
+     */
+    frame: AnnotationFrame;
+    /**
+     * The layer's own drawing of it, filling the frame: `<ng-container [ngTemplateOutlet]="native" />`
+     * keeps the original look, to add to it.
+     */
+    native: TemplateRef<unknown>;
+    /** The engine's picture of the annotation as an image (`url`), or `null`. `native` draws it in place. */
+    appearance: {
+        url: string;
+    } | null;
+    /** True while the pointer is over it. */
+    hovered: boolean;
+    /** True while it's selected. */
+    selected: boolean;
+    /** True when what you draw takes the pointer (see `epdfAnnotationInteractive`). */
+    interactive: boolean;
+}
+/**
+ * What a sibling plugin's template gets for the annotations its behavior owns (a form plugin's
+ * fill controls). It places its own controls: `item` is the layer's projection of the annotation
+ * in page coordinates, and `page.transform().toPixels()` turns those into the layer's pixels.
+ */
+interface EpdfAnnotationBehaviorTemplateContext {
+    $implicit: Annotation;
+    annotation: Annotation;
+    item: RenderItem;
+    page: EpdfPageContext;
+    /** The layer's own drawing of it, in its frame where the layer draws it. */
+    native: TemplateRef<unknown>;
+    hovered: boolean;
+    selected: boolean;
+    interactive: boolean;
+}
+/** One handle to draw yourself (`let-handle` in `<ng-template epdfHandle>`). */
+interface HandleProps {
+    /** The handle's center, in pixels on the page. */
+    readonly at: Point;
+    /** The `size` from the settings, px. */
+    readonly size: number;
+    /** The selection's rotation (degrees clockwise), so a square handle can turn with it. */
+    readonly rotation: number;
+    /** A box's `'corner'` or `'side'`, or one `'point'` of a line or a polygon. */
+    readonly kind: HandleRole;
+    /** True while it's being dragged. */
+    readonly active: boolean;
+}
+/** The rotation handle to draw yourself: a handle's props, and where its stalk starts on the box. */
+interface RotationHandleProps extends Omit<HandleProps, 'kind'> {
+    /** Where the stalk starts on the box, in pixels on the page. */
+    readonly from: Point;
+}
+interface EpdfHandleTemplateContext {
+    $implicit: HandleProps;
+}
+interface EpdfRotationHandleTemplateContext {
+    $implicit: RotationHandleProps;
+}
+interface EpdfRotationBadgeTemplateContext {
+    /** The turn in progress: its `page`, the pointer's point `at`, and the `angle` so far. */
+    $implicit: AnnotationRotationAnchor;
+}
+/** Which annotations a look draws: a function of the annotation, or every one of a subtype. */
+type AnnotationMatch = ((annotation: Annotation) => boolean) | AnnotationSubtype;
+/** Whether a look takes the pointer: always, never, or when the function says so. */
+type AnnotationInteractive = boolean | ((context: AnnotationInteractiveContext) => boolean);
+/** A look as `@embedpdf/web` sees it: a renderer entry, the same object for the same rule. */
+interface AnnotationLookRenderer {
+    readonly for: (annotation: Annotation) => boolean;
+    readonly interactive: AnnotationInteractive;
+    readonly scale: boolean;
+}
+/** A sibling plugin's renderer entry: it draws what the behavior `behavior` owns. */
+interface AnnotationBehaviorRenderer {
+    readonly behavior: string;
+}
+type AnnotationRendererEntry = AnnotationLookRenderer | AnnotationBehaviorRenderer;
+/**
+ * Your own look for some annotations: `<ng-template [epdfAnnotation]="isNote" let-annotation>`.
+ * Give it a function that picks annotations by any field, or a subtype
+ * (`epdfAnnotation="stamp"`). Without `epdfAnnotationInteractive` it only draws: the layer keeps
+ * handling the pointer (select, move, resize). With it (or a function the layer asks whenever it
+ * matters) your template takes the pointer, and the annotation can't be selected or moved while
+ * it does. `[epdfAnnotationScale]="false"` draws at the size on screen instead of the
+ * annotation's 100% size.
+ */
+declare class EpdfAnnotationTemplate {
+    /**
+     * Which annotations it draws: a function of the annotation, or a subtype. (Not a required
+     * input: a template inside `@if` is in the layer's query a moment before its inputs are set.)
+     */
+    readonly match: i0.InputSignal<AnnotationMatch | undefined>;
+    /** Whether it takes the pointer: present (or `true`), or a function of `{ annotation, toolId }`. */
+    readonly interactive: i0.InputSignalWithTransform<AnnotationInteractive, "" | "true" | "false" | AnnotationInteractive | null | undefined>;
+    /** Scale what you draw with the page (the default), or draw at the size on screen (`false`). */
+    readonly scale: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly template: TemplateRef<EpdfAnnotationTemplateContext>;
+    /** Its renderer entry, the same object on every page for the same rule; null until it has one. */
+    readonly renderer: Signal<AnnotationLookRenderer | null>;
+    static ngTemplateContextGuard(_directive: EpdfAnnotationTemplate, context: unknown): context is EpdfAnnotationTemplateContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfAnnotationTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EpdfAnnotationTemplate, "ng-template[epdfAnnotation]", never, { "match": { "alias": "epdfAnnotation"; "required": false; "isSignal": true; }; "interactive": { "alias": "epdfAnnotationInteractive"; "required": false; "isSignal": true; }; "scale": { "alias": "epdfAnnotationScale"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * What a sibling plugin's behavior owns, drawn by your template while the behavior is engaged:
+ * `<ng-template epdfAnnotationBehavior="form-fill" let-annotation let-item="item">`. The
+ * template places its own controls and takes the input.
+ */
+declare class EpdfAnnotationBehaviorTemplate {
+    /** The behavior's id, as its plugin registers it. */
+    readonly behavior: i0.InputSignal<string | undefined>;
+    readonly template: TemplateRef<EpdfAnnotationBehaviorTemplateContext>;
+    /** Its renderer entry, the same object for the same behavior; null until it has one. */
+    readonly renderer: Signal<AnnotationBehaviorRenderer | null>;
+    static ngTemplateContextGuard(_directive: EpdfAnnotationBehaviorTemplate, context: unknown): context is EpdfAnnotationBehaviorTemplateContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfAnnotationBehaviorTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EpdfAnnotationBehaviorTemplate, "ng-template[epdfAnnotationBehavior]", never, { "behavior": { "alias": "epdfAnnotationBehavior"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Each handle, drawn your way in place of the layer's: `<ng-template epdfHandle let-handle>`.
+ * The viewer still decides where a handle can be grabbed, so what you draw can't break dragging.
+ */
+declare class EpdfHandleTemplate {
+    readonly template: TemplateRef<EpdfHandleTemplateContext>;
+    static ngTemplateContextGuard(_directive: EpdfHandleTemplate, context: unknown): context is EpdfHandleTemplateContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfHandleTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EpdfHandleTemplate, "ng-template[epdfHandle]", never, {}, {}, never, never, true, never>;
+}
+/** The rotation handle, drawn your way: `<ng-template epdfRotationHandle let-handle>`. */
+declare class EpdfRotationHandleTemplate {
+    readonly template: TemplateRef<EpdfRotationHandleTemplateContext>;
+    static ngTemplateContextGuard(_directive: EpdfRotationHandleTemplate, context: unknown): context is EpdfRotationHandleTemplateContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfRotationHandleTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EpdfRotationHandleTemplate, "ng-template[epdfRotationHandle]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The rotation badge's content, drawn your way: inside `<epdf-annotation-rotation-badge>`,
+ * `<ng-template epdfRotationBadge let-rotation>{{ rotation.angle }}°</ng-template>`.
+ */
+declare class EpdfRotationBadgeTemplate {
+    readonly template: TemplateRef<EpdfRotationBadgeTemplateContext>;
+    static ngTemplateContextGuard(_directive: EpdfRotationBadgeTemplate, context: unknown): context is EpdfRotationBadgeTemplateContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfRotationBadgeTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EpdfRotationBadgeTemplate, "ng-template[epdfRotationBadge]", never, {}, {}, never, never, true, never>;
+}
+
+/** Your look of one annotation, with what its template gets. */
+interface DrawnLook {
+    readonly template: EpdfAnnotationTemplate;
+    readonly annotation: Annotation;
+    readonly frame: AnnotationFrame;
+    /** Drawn at the annotation's 100% size, and scaled by the layer. */
+    readonly scaled: boolean;
+    /** Tells a rich text editor in the look how much the look is scaled. */
+    readonly injector: Injector;
+}
+/** One annotation as the template draws it. */
+interface Drawn {
+    readonly item: RenderItem;
+    /** Its frame in the layer's pixels. */
+    readonly frame: FramePixels;
+    /** What its own drawing shows: the engine's picture of it, or its scene (`pictureOrPainting`). */
+    readonly shows: PictureOrPainting<RenderItem>;
+    /** The same picture as a look gets it: its `appearance`. */
+    readonly appearance: {
+        url: string;
+    } | null;
+    /** Your look that draws it, when one does. */
+    readonly look: DrawnLook | null;
+    /** A sibling plugin's template that owns it while its behavior is engaged. */
+    readonly owner: {
+        readonly template: EpdfAnnotationBehaviorTemplate;
+        readonly annotation: Annotation;
+    } | null;
+    /** The look takes the pointer. */
+    readonly interactive: boolean;
+    /** Keep the pointer and the focus out: a look that only draws, or a plugin's own input. */
+    readonly inert: boolean;
+}
+declare class EpdfAnnotationLayer {
+    protected readonly page: _embedpdf_angular_runtime.EpdfPageContext;
+    private readonly injector;
+    private readonly annotation;
+    private readonly interaction;
+    private readonly render;
+    private readonly chrome;
+    private readonly looks;
+    private readonly behaviors;
+    protected readonly handleTemplate: i0.Signal<EpdfHandleTemplate | undefined>;
+    protected readonly rotationHandleTemplate: i0.Signal<EpdfRotationHandleTemplate | undefined>;
+    /**
+     * The renderer entries, in the order the templates are written: the first look that matches
+     * wins. The same array while every entry stays the same.
+     */
+    private readonly renderers;
+    /** Goes up when the behaviors register again, so each drawing is decided again. */
+    private readonly registrations;
+    private readonly view;
+    private readonly pixels;
+    private readonly items;
+    private readonly allTexts;
+    /** The active tool: an interactive look's function is asked about it, so a tool change redraws. */
+    private readonly activeToolId;
+    /** The pictures' URLs, by annotation and state; `null` until the page's first ones arrive. */
+    private readonly urls;
+    /** The pictures shown stay valid until the next ones are shown. */
+    private readonly shown;
+    private readonly appearanceEpoch;
+    private readonly appearanceScale;
+    private readonly bakeScale;
+    /** The text box being typed in, by key: while it is, a look's editor takes the keys. */
+    private readonly editingKey;
+    /** One injector per look, by item: kept while the item is drawn, so the look is never made again. */
+    private readonly lookInjectors;
+    protected readonly drawings: i0.Signal<readonly Drawn[]>;
+    /** How much the layer scales each look, by item: 1 for a look drawn at its size on screen. */
+    private readonly lookScales;
+    /** The text boxes the layer draws: not the ones a look of yours draws, which edits them there. */
+    protected readonly texts: i0.Signal<readonly TextItem[]>;
+    protected readonly textOutline: i0.Signal<string>;
+    private readonly imageGhost;
+    private readonly armedStamp;
+    /**
+     * The ghost is a picture of vector artwork, sharp at one size: the size class that covers the
+     * box's device width. The plugin keeps one picture per class, so a zoom never renders per frame.
+     */
+    private readonly ghostBucket;
+    private readonly ghostUrl;
+    protected readonly ghost: i0.Signal<{
+        url: string;
+        box: _embedpdf_web.PixelRect;
+        opacity: string;
+        rotation: number;
+    } | null>;
+    constructor();
+    /** The injector a look's template gets for one item: the look's scale, followed live. */
+    private lookInjectorOf;
+    /**
+     * An interactive look takes the pointer through a behavior the plugin knows, registered once
+     * per document and look however many pages show the layer (`@embedpdf/web` counts them). The
+     * looks are the same entries on every page, so keep the functions you give `epdfAnnotation`
+     * and `epdfAnnotationInteractive` in fields: a function made anew registers again.
+     */
+    private registerBehaviors;
+    /**
+     * The baked pictures, loaded again when the page's appearance epoch or the bake scale changes;
+     * the ones shown stay valid until the next are shown.
+     */
+    private loadAppearances;
+    /**
+     * The armed stamp's ghost picture, for its size class. The previous class's picture stays up
+     * until this one is there, so a zoom across a class boundary never flickers; a disarm drops it.
+     */
+    private loadGhost;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfAnnotationLayer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EpdfAnnotationLayer, "epdf-annotation-layer", never, {}, {}, ["looks", "behaviors", "handleTemplate", "rotationHandleTemplate"], never, true, never>;
+}
+
+/**
+ * Your own element as the editor of a text box you draw yourself, in a look
+ * (`<ng-template [epdfAnnotation]="isTextBox" let-annotation>`):
+ *
+ *   <div [epdfRichTextEditor]="annotation" #editor="epdfRichTextEditor"
+ *        class="text-box" [class.editing]="editor.editing()"></div>
+ *
+ * It draws the runs, turns typing back into runs, keeps the caret when the style changes, and
+ * handles pasting, input methods and the format shortcuts; `text.toggleFormat()` and
+ * `selection.update()` work on it as on the layer's own box. It gives the element the box's
+ * body style (font, size, color and alignment), and while someone types it takes the pointer.
+ * Leave the element empty: the editor fills it.
+ */
+declare class EpdfRichTextEditor {
+    /** The free text annotation this element edits: the template's `let-annotation`. */
+    readonly annotation: i0.InputSignal<Annotation>;
+    private readonly page;
+    private readonly host;
+    private readonly lookScale;
+    private readonly view;
+    private readonly pixels;
+    /** The annotation's text box on the page, or null while there is none. */
+    private readonly item;
+    /** Pixels per point where the element is: in a scaled look, at the annotation's 100% size. */
+    private readonly scale;
+    /** The box's body style: font, size, color and alignment, or null while there is no box. */
+    protected readonly look: Signal<TextBoxStyle | null>;
+    /** True while someone types in the box. */
+    readonly editing: Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfRichTextEditor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EpdfRichTextEditor, "[epdfRichTextEditor]", ["epdfRichTextEditor"], { "annotation": { "alias": "epdfRichTextEditor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Your menu next to the selection: one menu, also for a selection over several pages, clear of
+ * the rotation handle. It hides while the selection is dragged, resized or turned. Put it inside
+ * `<epdf-stage>`, next to the page template, with what the menu holds between its tags:
+ *
+ *   <epdf-annotation-menu placement="bottom">
+ *     <button (click)="annotation.selection.delete()">Delete</button>
+ *   </epdf-annotation-menu>
+ */
+declare class EpdfAnnotationMenu {
+    /** Which side of the selection: `'top'` (the default), `'bottom'`, `'left'` or `'right'`, or a corner. */
+    readonly placement: i0.InputSignal<AnchoredPlacement>;
+    /** Screen pixels between the selection and the menu. */
+    readonly gap: i0.InputSignal<number>;
+    private readonly annotation;
+    private readonly projection;
+    /**
+     * The selection's anchor as its page is shown: the rotation handle sits a fixed number of
+     * pixels off the box, so where it is on the page depends on the zoom. Read again with the
+     * projection, in the same pass as the pages.
+     */
+    private readonly selection;
+    protected readonly anchor: Signal<EpdfAnchor | null>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfAnnotationMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EpdfAnnotationMenu, "epdf-annotation-menu", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * Buttons over a polygon or polyline being drawn, which helps on touch screens. `draft()` is the
+ * shape being drawn (`pointCount`, `minPoints`, `canFinish`, …), or null; the verbs are the
+ * annotation service's `draft.finish()` and `draft.cancel()`:
+ *
+ *   <epdf-annotation-draft-menu #menu="epdfAnnotationDraftMenu">
+ *     <button [disabled]="!menu.draft()?.canFinish" (click)="annotation.draft.finish()">Done</button>
+ *   </epdf-annotation-draft-menu>
+ */
+declare class EpdfAnnotationDraftMenu {
+    /** Which side of the shape being drawn. */
+    readonly placement: i0.InputSignal<AnchoredPlacement>;
+    /** Screen pixels between the shape and the menu. */
+    readonly gap: i0.InputSignal<number>;
+    private readonly annotation;
+    /** The shape being drawn: where it is, its points so far and whether it can end; or null. */
+    readonly draft: Signal<CreationDraft | null>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfAnnotationDraftMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EpdfAnnotationDraftMenu, "epdf-annotation-draft-menu", ["epdfAnnotationDraftMenu"], { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * The angle next to the pointer while a selection is turned, upright however the page is shown.
+ * It shows the angle in the `chrome.readout` colors when `chrome.readout.enabled`; give it an
+ * `<ng-template epdfRotationBadge let-rotation>` to draw it your way. `rotation()` is the turn
+ * in progress (`page`, `at`, `angle`), or null.
+ */
+declare class EpdfAnnotationRotationBadge {
+    /** Which side of the pointer. */
+    readonly placement: i0.InputSignal<AnchoredPlacement>;
+    /** Screen pixels between the pointer and the badge. */
+    readonly gap: i0.InputSignal<number>;
+    private readonly annotation;
+    private readonly settings;
+    protected readonly custom: Signal<EpdfRotationBadgeTemplate | undefined>;
+    /** The turn in progress: its page, the pointer's point and the angle so far; or null. */
+    readonly rotation: Signal<AnnotationRotationAnchor | null>;
+    /** Shown while turning, with a template of yours or with the readout on. */
+    protected readonly shown: Signal<_embedpdf_core_annotation.RotationAnchor | null>;
+    /** A box of no size at the pointer. */
+    protected readonly anchor: Signal<EpdfAnchor | null>;
+    protected readonly fontFamily: string;
+    protected readonly background: Signal<string>;
+    protected readonly color: Signal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfAnnotationRotationBadge, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EpdfAnnotationRotationBadge, "epdf-annotation-rotation-badge", ["epdfAnnotationRotationBadge"], { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; }, {}, ["custom"], never, true, never>;
+}
+
+export { EpdfAnnotation, EpdfAnnotationBehaviorTemplate, EpdfAnnotationDraftMenu, EpdfAnnotationLayer, EpdfAnnotationMenu, EpdfAnnotationRotationBadge, EpdfAnnotationTemplate, EpdfComments, EpdfHandleTemplate, EpdfRichTextEditor, EpdfRotationBadgeTemplate, EpdfRotationHandleTemplate, filePickerProvider, withAnnotation, withFilePicker };
+export type { AnnotationBehaviorRenderer, AnnotationFrame, AnnotationInteractive, AnnotationInteractiveContext, AnnotationLookRenderer, AnnotationMatch, AnnotationRendererEntry, CommentThreadView, EpdfAnnotationBehaviorTemplateContext, EpdfAnnotationSelection, EpdfAnnotationTemplateContext, EpdfAnnotationTools, EpdfHandleTemplateContext, EpdfRotationBadgeTemplateContext, EpdfRotationHandleTemplateContext, HandleProps, RotationHandleProps };