@embedpdf/angular 3.0.0-next.14 → 3.0.0-next.16

package/dist/link/index.d.ts

@@ -0,0 +1,77 @@
+import * as _embedpdf_plugin_link from '@embedpdf/plugin-link';
+import { Link } from '@embedpdf/plugin-link';
+export * from '@embedpdf/plugin-link';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
+import * as i0 from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import * as _embedpdf_plugin_annotation_contract from '@embedpdf/plugin-annotation/contract';
+import { LinkAnchor, LinkAnchorEvent } from '@embedpdf/web';
+
+declare const EpdfLink_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_link.LinkCapability, Record<never, never>, "activate" | "getStatus" | "listLinks" | "getLink" | "getLinkAt" | "listAllLinks" | "ensureLoaded" | "isLoaded" | "resolve" | "activateAt" | "getLabel", "onActivated" | "onLoaded">;
+/**
+ * Links: `listLinks(page)`, `getLinkAt(page, point)`, `activate(link)` and the rest of the Links
+ * page's methods, and its events as streams (`link.activated$`). While the service is there,
+ * `activate()` opens a website in a new tab.
+ */
+declare class EpdfLink extends EpdfLink_base {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfLink, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfLink>;
+}
+/** The link plugin: links that work, in every page with an `<epdf-link-layer>`. */
+declare function withLink(): EmbedPdfFeature;
+
+/** What a link template gets: `let-link` is the link, `let-native="native"` the layer's anchor. */
+interface EpdfLinkTemplateContext {
+    /** The link: its `id`, its `bounds` on the page and its `target`. */
+    $implicit: Link;
+    /** The layer's own anchor: `<ng-container [ngTemplateOutlet]="native" />`. */
+    native: TemplateRef<unknown>;
+}
+/**
+ * How each link is drawn instead of the layer's bare anchor:
+ * `<ng-template epdfLink let-link let-native="native">`. For a link you don't want to change,
+ * show `native` alone.
+ */
+declare class EpdfLinkTemplate {
+    readonly template: TemplateRef<EpdfLinkTemplateContext>;
+    static ngTemplateContextGuard(_directive: EpdfLinkTemplate, context: unknown): context is EpdfLinkTemplateContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfLinkTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EpdfLinkTemplate, "ng-template[epdfLink]", never, {}, {}, never, never, true, never>;
+}
+declare class EpdfLinkLayer {
+    private readonly page;
+    private readonly host;
+    private readonly enclosingStage;
+    /** The app's own drawing of a link, when it gives one. */
+    protected readonly custom: i0.Signal<EpdfLinkTemplate | undefined>;
+    /** A plugin of the page's own document: every plugin below is read for it. */
+    private bindTo;
+    private readonly link;
+    /** Optional: with the actions plugin, a link's own actions run. */
+    private readonly actions;
+    /** Optional: a tool that can edit annotations owns the links that belong to one. */
+    private readonly editing;
+    /** A link to a page moves the view it was followed in: this Stage, or the main one. */
+    private readonly stage;
+    private readonly links;
+    /** Whether the active tool follows links: the layer draws nothing otherwise. */
+    private readonly engaged;
+    /** Each link's anchor: its box, its label, and a native `href` only for a website with nothing chained after it. */
+    protected readonly items: i0.Signal<readonly LinkAnchor<_embedpdf_plugin_annotation_contract.LinkNavItem>[]>;
+    /** One hover pump per layer: the enter and exit actions of the link under the pointer. */
+    private readonly pump;
+    constructor();
+    protected follow(event: MouseEvent, item: LinkAnchor<Link>): void;
+    protected followByKey(event: KeyboardEvent, link: Link): void;
+    protected hover(link: Link | null): void;
+    /** Send one of the link's own events to the actions plugin, when the link has actions. */
+    protected notify(link: Link, event: LinkAnchorEvent): void;
+    private activate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfLinkLayer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EpdfLinkLayer, "epdf-link-layer", never, {}, {}, ["custom"], never, true, never>;
+}
+
+export { EpdfLink, EpdfLinkLayer, EpdfLinkTemplate, withLink };
+export type { EpdfLinkTemplateContext };

package/dist/measurement/index.d.ts

@@ -0,0 +1,46 @@
+import * as _embedpdf_plugin_measurement from '@embedpdf/plugin-measurement';
+import { PageScale, AnnotationRef, MeasurementReadout, MeasurementUnavailable, MeasurementConfig } from '@embedpdf/plugin-measurement';
+export * from '@embedpdf/plugin-measurement';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { PageRef } from '@embedpdf/core';
+
+/** A page, or a function that gives the page to follow. */
+type PageInput<Page> = Page | (() => Page);
+declare const EpdfMeasurement_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_measurement.MeasurementCapability, {
+    busy: boolean;
+    calibrationRequest: _embedpdf_plugin_measurement.CalibrationRequest | null;
+    lastReports: readonly _embedpdf_plugin_measurement.ScaleChangeReport[];
+}, "calibrate" | "canCalibrate" | "canMeasure" | "getPageScale" | "ensureLoaded" | "isBusy" | "listLastReports" | "listPresets" | "listUnits" | "listAreaUnits" | "getReadout" | "measureDistance" | "measureArea" | "getCalibrationRequest" | "setScale" | "setUnit" | "setAreaUnit" | "setPrecision" | "setPreset" | "clearScale" | "createMeasurement" | "startCalibration" | "dismissCalibration", "onScaleChanged" | "onCalibrationRequested" | "onCalibrationCompleted" | "onCalibrationDismissed">;
+/**
+ * Measurements of the document in scope (`[epdfDocumentScope]`), else the active one: the
+ * Measurements page's methods, its State table as signals, a page's scale and a measurement's
+ * readout as signals, the events as streams (`scaleChanged$`, `calibrationRequested$`, …), and
+ * the settings. Without a document the signals read empty and the methods refuse with
+ * `not-ready`.
+ */
+declare class EpdfMeasurement extends EpdfMeasurement_base {
+    /**
+     * A page's scale (its ref or its index), for a scale bar or a "1:100" badge: where it came
+     * from, and whether it has loaded. Pass a function (`() => this.page().ref`) and it follows
+     * the page you show; `null` (no page) answers `null`, so a badge can stay without inventing a
+     * page. It changes only when that page's scale does.
+     */
+    scaleOf(page: PageInput<PageRef | number>): Signal<PageScale>;
+    scaleOf(page: PageInput<PageRef | number | null>): Signal<PageScale | null>;
+    /**
+     * A measurement's `{ kind, value, label }`, or `{ unavailable }` with why there's none (no
+     * scale, a scale from map software). Pass a function (`this.annotation`, an input) and it
+     * follows the measurement you show. The plugin hands out the same readout until the
+     * measurement changes, so it changes only then.
+     */
+    readoutOf(ref: AnnotationRef | (() => AnnotationRef)): Signal<MeasurementReadout | MeasurementUnavailable>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfMeasurement, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfMeasurement>;
+}
+/** Measurements, with their settings: `withMeasurement({ defaultScale: 'imperial' })`. */
+declare function withMeasurement(options?: MeasurementConfig): EmbedPdfFeature;
+
+export { EpdfMeasurement, withMeasurement };

package/dist/metadata/index.d.ts

@@ -0,0 +1,51 @@
+import * as _embedpdf_plugin_metadata from '@embedpdf/plugin-metadata';
+import { CustomMetadataCapability, CustomMetadataUpdatedEvent, CustomMetadataResyncedEvent } from '@embedpdf/plugin-metadata';
+export * from '@embedpdf/plugin-metadata';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { CustomMetadata, ResourceStatus, DocumentMetadata, EmbedPdfFeature } from '@embedpdf/angular/runtime';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+
+/** Your own fields of a document, as `metadata.custom`: the same reads and calls as the standard ones. */
+interface EpdfCustomMetadata {
+    /** Your own fields, as `{ name: value }`, or null until they have loaded. */
+    readonly fields: Signal<CustomMetadata | null>;
+    /** `'idle'`, `'loading'`, `'ready'`, `'forbidden'` or `'error'`. */
+    readonly status: Signal<ResourceStatus>;
+    /** A string sets a field, `null` removes it, and the fields left out stay. Resolves `{ custom }`. */
+    readonly update: CustomMetadataCapability['update'];
+    /** Read your own fields from the file again. Rarely needed: they stay up to date by themselves. */
+    readonly refresh: CustomMetadataCapability['refresh'];
+    /** Your own fields, read once. */
+    readonly getSnapshot: CustomMetadataCapability['getSnapshot'];
+    /** Their load state, read once. */
+    readonly getStatus: CustomMetadataCapability['getStatus'];
+    /** Your own fields changed, by you or by someone else. */
+    readonly updated$: Observable<CustomMetadataUpdatedEvent>;
+    /** Your own fields were loaded from the file. */
+    readonly resynced$: Observable<CustomMetadataResyncedEvent>;
+}
+declare const EpdfMetadata_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_metadata.MetadataCapability, Record<never, never>, "getSnapshot" | "getStatus" | "ensureLoaded" | "canUpdate" | "update" | "refresh", "onUpdated" | "onResynced">;
+/**
+ * The metadata of the document in scope (`[epdfDocumentScope]`), else the active one: the
+ * standard fields as `fields()`, their load state as `status()`, `update()`, `refresh()`,
+ * `ensureLoaded()` (the service calls it for the document it reads), the
+ * check `canUpdate()`, the streams `updated$` and `resynced$`, and your own fields as `custom`.
+ * With no document the signals read null and `'idle'`, and every call refuses with `not-ready`.
+ */
+declare class EpdfMetadata extends EpdfMetadata_base {
+    /** Every standard field (`title`, `author`, …), or null until it has loaded. */
+    readonly fields: Signal<DocumentMetadata | null>;
+    /** Whether the standard fields are still loading, there, or not allowed. */
+    readonly status: Signal<ResourceStatus>;
+    /** Your own fields, kept in the document: a contract number, who reviewed it. */
+    readonly custom: EpdfCustomMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfMetadata, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfMetadata>;
+}
+/** Metadata, for `provideEmbedPdf()`. */
+declare function withMetadata(): EmbedPdfFeature;
+
+export { EpdfMetadata, withMetadata };
+export type { EpdfCustomMetadata };

package/dist/outline/index.d.ts

@@ -0,0 +1,32 @@
+import * as _embedpdf_plugin_outline from '@embedpdf/plugin-outline';
+export * from '@embedpdf/plugin-outline';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
+import * as _embedpdf_core from '@embedpdf/core';
+import * as i0 from '@angular/core';
+
+declare const EpdfOutline_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_outline.OutlineCapability, {
+    items: readonly _embedpdf_plugin_outline.OutlineItem<_embedpdf_core.PageDestination>[];
+    rows: readonly _embedpdf_plugin_outline.OutlineRow[];
+    current: _embedpdf_plugin_outline.OutlineItemRef | null;
+    selected: readonly _embedpdf_plugin_outline.OutlineItemRef[];
+    status: _embedpdf_core.ResourceStatus;
+    incomplete: boolean;
+    canEdit: boolean;
+}, "activate" | "create" | "get" | "move" | "select" | "delete" | "toggle" | "refresh" | "update" | "ensureLoaded" | "getChildren" | "isExpanded" | "expand" | "collapse" | "expandAll" | "collapseAll" | "reveal" | "getCurrentViewTarget", "onResynced" | "onChanged">;
+/**
+ * The outline of the document in scope (`[epdfDocumentScope]`), else the active one: the State
+ * table as signals (`items()`, `rows()`, `current()`, `selected()`, `status()`, `incomplete()`,
+ * `canEdit()`), the reads that take an item (`get()`, `getChildren()`, `isExpanded()`), the
+ * calls that expand, select, follow and edit items, and the streams `changed$` and
+ * `resynced$`. Reading it reads the outline. With no document the signals read empty, and every
+ * call refuses with `not-ready`.
+ */
+declare class EpdfOutline extends EpdfOutline_base {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfOutline, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfOutline>;
+}
+/** The outline, for `provideEmbedPdf()`. */
+declare function withOutline(): EmbedPdfFeature;
+
+export { EpdfOutline, withOutline };

package/dist/page-edit/index.d.ts

@@ -0,0 +1,27 @@
+import * as _embedpdf_plugin_page_edit from '@embedpdf/plugin-page-edit';
+export * from '@embedpdf/plugin-page-edit';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
+import * as _embedpdf_core from '@embedpdf/core';
+import * as i0 from '@angular/core';
+
+declare const EpdfPageEdit_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_page_edit.PageEditCapability, {
+    selected: readonly _embedpdf_core.PageRef[];
+    canEdit: boolean;
+    canExtract: boolean;
+}, "canEdit" | "canExtract" | "select" | "rotateBy" | "setRotation" | "reorder" | "delete" | "insertBlank" | "insertFromBytes" | "insertFromDocument" | "duplicate" | "extract", never>;
+/**
+ * The page edits of the document in scope (`[epdfDocumentScope]`), else the active one. The
+ * checks `canEdit()` and `canExtract()` follow the document when a template reads them; with no
+ * document every call refuses with `not-ready`. `selected()` is the selection, a signal. The
+ * plugin has no events of its own: page changes are document events
+ * (`inject(EpdfDocuments).pagesChanged$`), and the pages are `inject(EpdfDocument).pages()`.
+ */
+declare class EpdfPageEdit extends EpdfPageEdit_base {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfPageEdit, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfPageEdit>;
+}
+/** Page editing, for `provideEmbedPdf()`. */
+declare function withPageEdit(): EmbedPdfFeature;
+
+export { EpdfPageEdit, withPageEdit };

package/dist/page-view/index.d.ts

@@ -0,0 +1,94 @@
+import * as _embedpdf_web from '@embedpdf/web';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Signal } from '@angular/core';
+import { PageRef } from '@embedpdf/core';
+import { PageFrame, PageTransform } from '@embedpdf/core-geometry';
+import { EpdfDocumentScopeRef, EpdfPageContext } from '@embedpdf/angular/runtime';
+import { EpdfProjectorBinding } from '@embedpdf/angular/anchored';
+import { EpdfPageTemplateContext } from '@embedpdf/angular/stage';
+export { EpdfPageChrome, EpdfPageTemplateContext } from '@embedpdf/angular/stage';
+
+/**
+ * What a page view shows until its document and its page are there, instead of nothing:
+ * `<ng-template epdfFallback>Loading…</ng-template>`.
+ */
+declare class EpdfFallback {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfFallback, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EpdfFallback, "ng-template[epdfFallback]", never, {}, {}, never, never, true, never>;
+}
+declare class EpdfPageView {
+    /** The page: its `ref`, which follows it when pages move, or its index, from 0. */
+    readonly page: _angular_core.InputSignal<number | PageRef>;
+    /**
+     * Which document to show. Without it, the one the surrounding `[epdfDocumentScope]` names,
+     * else the active one.
+     */
+    readonly documentId: _angular_core.InputSignal<string | null | undefined>;
+    /** The width of the page upright, in pixels: a page turned a quarter is that tall. */
+    readonly width: _angular_core.InputSignal<number>;
+    /** Space reserved around the page for your own labels, in pixels per side; 0 for the others. */
+    readonly pageFrame: _angular_core.InputSignal<Partial<PageFrame> | null | undefined>;
+    private readonly host;
+    private readonly parentScope;
+    private readonly content;
+    private readonly chromeDirective;
+    private readonly fallbackDirective;
+    protected readonly chromeTemplate: Signal<TemplateRef<EpdfPageTemplateContext> | null>;
+    protected readonly fallbackTemplate: Signal<TemplateRef<unknown> | null>;
+    private readonly activeId;
+    /** The document shown: `[documentId]`, else the scope's, else the active one. */
+    private readonly docId;
+    /** For what's inside: services and layers talk to the document shown. */
+    readonly documentScope: EpdfDocumentScopeRef;
+    /** The interaction plugin of the document shown, when the viewer has it. */
+    private readonly interaction;
+    /**
+     * The page's entry in the document, by its object number or its index. Entries stay the
+     * same object until their page changes, so a turn or a move reads as a new entry.
+     */
+    private readonly entry;
+    /** Whether there's a page to show: the document is there and has it. */
+    protected readonly shown: Signal<boolean>;
+    /** Whether the tools take the pointer here: with the interaction plugin, as on a Stage. */
+    protected readonly takesPointer: Signal<boolean>;
+    private readonly pageIndex;
+    /** The page's object number: a stand-in (its index + 1) only until the page is known. */
+    private readonly objectNumber;
+    /** The same ref object while the page is the same, so layers can key their work on it. */
+    private readonly pageRef;
+    protected readonly frame: Signal<PageFrame>;
+    private readonly dpr;
+    /** What the transform depends on, by value: a new entry for an unchanged page changes nothing. */
+    private readonly geometry;
+    /**
+     * The page's transform, from the width alone (`pageViewTransformInput` from `@embedpdf/web`,
+     * the same in every framework): view pixels per point is `width / page width`, and 100% is 1
+     * point = 96/72 CSS pixels times the page's user unit, as on a Stage.
+     */
+    protected readonly transform: Signal<PageTransform>;
+    /** The outer box, the shadow at the footprint, and the turned content box. */
+    protected readonly layout: Signal<_embedpdf_web.PageSurfaceLayout>;
+    /** The viewer's `page` settings; CSS `--epdf-page-shadow` and `--epdf-page-background` win. */
+    private readonly look;
+    protected readonly shadow: Signal<string>;
+    protected readonly background: Signal<string>;
+    private readonly viewId;
+    /**
+     * The page context for the layers inside: one object for the view's lifetime, whose `ref`,
+     * `documentId` and signals follow `[page]` and `[documentId]`. No view demand: a page view
+     * wants the whole page.
+     */
+    readonly pageContext: EpdfPageContext;
+    protected readonly templateContext: EpdfPageTemplateContext;
+    /**
+     * How anchored UI inside follows the page: by measuring it on screen. The revision is the
+     * page and its transform; a scroll or a resize of the window moves the page without either,
+     * so `observeClientGeometry` reports those.
+     */
+    readonly projection: EpdfProjectorBinding;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfPageView, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EpdfPageView, "epdf-page-view", never, { "page": { "alias": "page"; "required": true; "isSignal": true; }; "documentId": { "alias": "documentId"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "pageFrame": { "alias": "pageFrame"; "required": false; "isSignal": true; }; }, {}, ["chromeDirective", "fallbackDirective"], ["*"], true, never>;
+}
+
+export { EpdfFallback, EpdfPageView };

package/dist/redaction/index.d.ts

@@ -0,0 +1,38 @@
+import * as _embedpdf_plugin_redaction from '@embedpdf/plugin-redaction';
+import { RedactionApplyResult, RedactionMark, RedactionConfig } from '@embedpdf/plugin-redaction';
+export * from '@embedpdf/plugin-redaction';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { PageRef } from '@embedpdf/core';
+
+declare const EpdfRedaction_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_redaction.RedactionCapability, {
+    pendingCount: number;
+    applying: boolean;
+    lastResult: RedactionApplyResult | null;
+}, "apply" | "canMark" | "canUnmark" | "canUpdateLabel" | "canApply" | "isApplying" | "getLastResult" | "listPending" | "getPending" | "getPendingCount" | "estimateCollateral" | "markSelection" | "markArea" | "markPage" | "markMatches" | "unmark" | "clearPending" | "updateLabel" | "applyAll" | "applyPages", "onApplied" | "onPendingChanged">;
+/**
+ * Redaction in the document in scope (`[epdfDocumentScope]`), else the active one: the
+ * Redaction page's methods, its State table as signals, the marks waiting to be applied as
+ * signals, the events as streams (`applied$`, `pendingChanged$`), and the settings. Without a
+ * document the signals read empty and the methods refuse with `not-ready`.
+ */
+declare class EpdfRedaction extends EpdfRedaction_base {
+    /**
+     * The marks waiting to be applied, in page order, for a review panel. The plugin hands out
+     * the same list until a mark changes, so a list redraws only then. Empty without a document.
+     */
+    readonly pending: Signal<readonly RedactionMark[]>;
+    /**
+     * One page's marks (its ref or its index). Pass a function (`() => this.page().ref`) and it
+     * follows the page you show. Empty for a page without marks, and without a document.
+     */
+    pendingOn(page: PageRef | number | (() => PageRef | number)): Signal<readonly RedactionMark[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfRedaction, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfRedaction>;
+}
+/** Redaction, with its settings: `withRedaction({ overlay: { fill: '#1d2b53' } })`. */
+declare function withRedaction(options?: RedactionConfig): EmbedPdfFeature;
+
+export { EpdfRedaction, withRedaction };

package/dist/render/index.d.ts

@@ -1,19 +1,58 @@
+import * as _embedpdf_plugin_render from '@embedpdf/plugin-render';
+import { RenderConfig } from '@embedpdf/plugin-render';
 export * from '@embedpdf/plugin-render';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
 import * as _angular_core from '@angular/core';
+import * as _embedpdf_web from '@embedpdf/web';
+import { PaintSettings } from '@embedpdf/plugin-render/contract/host';
+
+declare const EpdfRender_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_render.RenderCapability, Record<never, never>, "canRender" | "renderPage" | "renderThumbnail" | "renderPages" | "getRenderPolicy" | "getRenderEpoch" | "invalidate", "onInvalidated">;
+/**
+ * Pictures of pages, apart from the Stage: a thumbnail, a page at an exact width, every page in
+ * batches. `invalidate()` redraws pages, `invalidated$` tells you when they were, and
+ * `settings()` / `updateSettings()` are the picture budget and tiles.
+ */
+declare class EpdfRender extends EpdfRender_base {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfRender, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EpdfRender>;
+}
+/** The render plugin, with its settings: `withRender({ fullPage: { maxWidth: 1280 } })`. */
+declare function withRender(options?: RenderConfig): EmbedPdfFeature;
 
 declare class EpdfRenderLayer {
     /**
-     * Bake annotations into the page bitmap (default true). Pass false when an
-     * annotation layer owns annotation rendering, so they aren't drawn twice.
+     * Draw the annotations into the page's picture (`true`) or leave them out (`false`). Left
+     * unset, the picture leaves them to an `<epdf-annotation-layer>` on the page, and otherwise
+     * draws them when the user may read them.
+     */
+    readonly annotations: _angular_core.InputSignal<boolean | undefined>;
+    /** The same for the form fields, which an `<epdf-form-layer>` paints. */
+    readonly formFields: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * The sharp tiles over the picture when zoomed in (default true). Whether they cost anything
+     * is decided by what the view wants; set it to false only for a view that must never tile.
      */
-    readonly annotations: _angular_core.InputSignal<boolean>;
+    readonly tiles: _angular_core.InputSignal<boolean>;
     private readonly page;
     private readonly render;
+    /** The same object until a setting it reads changes. */
+    protected readonly paintSettings: _angular_core.Signal<PaintSettings>;
+    private readonly parts;
+    private readonly painted;
+    private readonly may;
+    /** The parts the picture draws; `null` until the page's layers have said what they paint. */
+    protected readonly layers: _angular_core.Signal<_embedpdf_web.PictureLayerOptions | null>;
+    /**
+     * The picture's identity: its size, the parts it draws and the page's version. Within a
+     * size step it doesn't move as you zoom (the page's transform scales the picture), so
+     * nothing is fetched again; it moves at a step and when the page changes.
+     */
     private readonly sourceKey;
-    protected readonly src: _angular_core.WritableSignal<string | null>;
+    private readonly picture;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfRenderLayer, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EpdfRenderLayer, "epdf-render-layer", never, { "annotations": { "alias": "annotations"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EpdfRenderLayer, "epdf-render-layer", never, { "annotations": { "alias": "annotations"; "required": false; "isSignal": true; }; "formFields": { "alias": "formFields"; "required": false; "isSignal": true; }; "tiles": { "alias": "tiles"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { EpdfRenderLayer };
+export { EpdfRender, EpdfRenderLayer, withRender };