@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/images/image-sniff.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @public PNG media type (ECMA-376-1 §15.2.14). */
+export declare const PNG_CONTENT_TYPE = "image/png";
+/**
+ * @public JPEG media type (ECMA-376-1 §15.2.14). */
+export declare const JPEG_CONTENT_TYPE = "image/jpeg";
+/** Supported image content types for create/replace.
+ * @public
+ */
+export declare type ImageType = typeof PNG_CONTENT_TYPE | typeof JPEG_CONTENT_TYPE;
+/**
+ * @private
+ * Pixel dimensions when sniffable from PNG or JPEG bytes. */
+export declare function sniffImagePixelDimensions(bytes: Uint8Array): {
+    width: number;
+    height: number;
+} | undefined;
+/**
+ * @private
+ * Sniff PNG/JPEG content type from magic bytes. */
+export declare function sniffImageContentType(bytes: Uint8Array): ImageType | undefined;

package/src/features/images/image-sniff.js

@@ -0,0 +1,71 @@
+/**
+ * @public PNG media type (ECMA-376-1 §15.2.14). */
+export var PNG_CONTENT_TYPE = 'image/png';
+/**
+ * @public JPEG media type (ECMA-376-1 §15.2.14). */
+export var JPEG_CONTENT_TYPE = 'image/jpeg';
+function readUint32Be(bytes, offset) {
+    var __ts33_0, __ts33_1, __ts33_2;
+    return (((bytes[offset] != null ? bytes[offset] : 0) << 24) |
+        ((((__ts33_0 = bytes[offset + 1]), __ts33_0 != null ? __ts33_0 : 0)) << 16) |
+        ((((__ts33_1 = bytes[offset + 2]), __ts33_1 != null ? __ts33_1 : 0)) << 8) |
+        (((__ts33_2 = bytes[offset + 3]), __ts33_2 != null ? __ts33_2 : 0))) >>> 0;
+}
+/**
+ * @private
+ * Pixel dimensions when sniffable from PNG or JPEG bytes. */
+export function sniffImagePixelDimensions(bytes) {
+    var __ts33_3, __ts33_4, __ts33_5, __ts33_6, __ts33_7, __ts33_8;
+    if (bytes.length >= 24 &&
+        bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47) {
+        return { width: readUint32Be(bytes, 16), height: readUint32Be(bytes, 20) };
+    }
+    if (bytes.length >= 4 && bytes[0] === 0xff && bytes[1] === 0xd8) {
+        var offset = 2;
+        while (offset + 9 < bytes.length) {
+            if (bytes[offset] !== 0xff) {
+                break;
+            }
+            var marker = bytes[offset + 1];
+            if (marker === undefined) {
+                break;
+            }
+            if (marker === 0xd9 || marker === 0xda) {
+                break;
+            }
+            var segmentLength = ((((__ts33_3 = bytes[offset + 2]), __ts33_3 != null ? __ts33_3 : 0)) << 8) | (((__ts33_4 = bytes[offset + 3]), __ts33_4 != null ? __ts33_4 : 0));
+            if (segmentLength < 2) {
+                break;
+            }
+            if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+                var height = ((((__ts33_5 = bytes[offset + 5]), __ts33_5 != null ? __ts33_5 : 0)) << 8) | (((__ts33_6 = bytes[offset + 6]), __ts33_6 != null ? __ts33_6 : 0));
+                var width = ((((__ts33_7 = bytes[offset + 7]), __ts33_7 != null ? __ts33_7 : 0)) << 8) | (((__ts33_8 = bytes[offset + 8]), __ts33_8 != null ? __ts33_8 : 0));
+                if (width > 0 && height > 0) {
+                    return { width: width, height: height };
+                }
+                return undefined;
+            }
+            offset += 2 + segmentLength;
+        }
+    }
+    return undefined;
+}
+/**
+ * @private
+ * Sniff PNG/JPEG content type from magic bytes. */
+export function sniffImageContentType(bytes) {
+    if (bytes.length >= 8 &&
+        bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47) {
+        return PNG_CONTENT_TYPE;
+    }
+    if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
+        return JPEG_CONTENT_TYPE;
+    }
+    return undefined;
+}

package/src/features/images/index.d.ts

@@ -0,0 +1,506 @@
+export * from './caption-authoring-api';
+export * from './caption-enums';
+export * from './caption-host';
+export * from './captions';
+export * from './host-codec';
+export * from './image-sniff';
+export * from './layout-types';
+import { FeatureRunLeaf } from '../document/feature-run-leaf';
+import { WordDocument } from '../document/document';
+import { FeatureMultiPackagePart } from '../document/feature-multi-package-part';
+import { EntityType } from '../document/entity-type';
+import { Paragraph } from '../document/paragraph';
+import { FeatureRunParagraphItem, ParagraphItem } from '../document/text-range';
+import { OpcRelationship, RelationshipId } from '../../core/opc/relationships';
+import { OpcPackage } from '../../core/opc/package';
+import { PartName } from '../../core/opc/part-name';
+import { CaptionNumberingFormat, CaptionPosition } from './caption-enums';
+import { PictureHostState } from './host-codec';
+import { HorizontalAlignment as HorizontalAlignmentType, HorizontalOrigin as HorizontalOriginType, PicturePlacement as PicturePlacementType, TextWrappingStyle as TextWrappingStyleType, VerticalAlignment as VerticalAlignmentType, VerticalOrigin as VerticalOriginType } from './layout-types';
+import { OpenXmlElement } from '../../core/xml/index';
+/**
+ * @private Transitional image relationship (ECMA-376-4 §9.2.10). */
+export declare const IMAGE_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+/**
+ * @private Strict image relationship (ECMA-376-1 §11.3.10). */
+export declare const STRICT_IMAGE_RELATIONSHIP_TYPE = "http://purl.oclc.org/ooxml/officeDocument/relationships/image";
+/**
+ * @private PNG media type (ECMA-376-1 §15.2.14). */
+declare const PNG_CONTENT_TYPE = "image/png";
+/**
+ * @private JPEG media type (ECMA-376-1 §15.2.14). */
+declare const JPEG_CONTENT_TYPE = "image/jpeg";
+/** Supported image content types for create/replace.
+ * @public
+ */
+declare type ImageType = typeof PNG_CONTENT_TYPE | typeof JPEG_CONTENT_TYPE;
+/** Options for {@link Paragraph.appendImage}. */
+export interface ImageOptions {
+    /**
+     * Display width in points. When omitted, derived from intrinsic pixels
+     * (96 DPI → points), aspect ratio from height, or {@link DEFAULT_IMAGE_WIDTH_PT}.
+     */
+    readonly width?: number;
+    /**
+     * Display height in points. When omitted, derived from intrinsic pixels,
+     * aspect ratio from width, or {@link DEFAULT_IMAGE_HEIGHT_PT}.
+     */
+    readonly height?: number;
+    /** Media type of `bytes`. Sniffed from PNG/JPEG magic bytes when omitted. */
+    readonly imageType?: ImageType;
+    /**
+     * Non-visual picture name (`wp:docPr/@name` and `pic:cNvPr/@name`).
+     * @defaultValue `'Picture'`
+     */
+    readonly name?: string;
+    /**
+     * Accessibility / caption title (`wp:docPr/@title`).
+     * Distinct from {@link description} (`@descr`).
+     */
+    readonly title?: string;
+    /** Alternative text description (`wp:docPr/@descr`). */
+    readonly description?: string;
+    /**
+     * Whether aspect ratio is locked (`a:graphicFrameLocks/@noChangeAspect`).
+     * @defaultValue `true`
+     */
+    readonly lockAspectRatio?: boolean;
+    /** Clockwise rotation in degrees (`a:xfrm/@rot`, ST_Angle × 60000). */
+    readonly rotation?: number;
+    /** Horizontal flip (`a:xfrm/@flipH`). */
+    readonly flipHorizontal?: boolean;
+    /** Vertical flip (`a:xfrm/@flipV`). */
+    readonly flipVertical?: boolean;
+    /**
+     * Host placement. Prefer {@link textWrappingStyle}; non-inline wrapping promotes to
+     * `wp:anchor` automatically.
+     */
+    readonly placement?: PicturePlacementType;
+    /**
+     * Text wrapping. `'inline'` uses `wp:inline`; any other value promotes to
+     * `wp:anchor` with the matching `wp:wrap*` child.
+     * @defaultValue `'inline'`
+     */
+    readonly textWrappingStyle?: TextWrappingStyleType;
+    /**
+
+     */
+    readonly wrapping?: TextWrappingStyleType;
+    /** `wp:positionH/@relativeFrom` (`ST_RelFromH`). Meaningful on anchored hosts. */
+    readonly horizontalOrigin?: HorizontalOriginType;
+    /** `wp:positionV/@relativeFrom` (`ST_RelFromV`). Meaningful on anchored hosts. */
+    readonly verticalOrigin?: VerticalOriginType;
+    /**
+     * Absolute offset on the horizontal axis (`wp:positionH/wp:posOffset`).
+     * Mutually exclusive with {@link horizontalAlignment}.
+     */
+    readonly horizontalPosition?: number;
+    /**
+     * Absolute offset on the vertical axis (`wp:positionV/wp:posOffset`).
+     * Mutually exclusive with {@link verticalAlignment}.
+     */
+    readonly verticalPosition?: number;
+    /**
+     * Alignment on the horizontal axis (`wp:positionH/wp:align`, `ST_AlignH`).
+     * Mutually exclusive with {@link horizontalPosition}.
+     */
+    readonly horizontalAlignment?: HorizontalAlignmentType;
+    /**
+     * Alignment on the vertical axis (`wp:positionV/wp:align`, `ST_AlignV`).
+     * Mutually exclusive with {@link verticalPosition}.
+     */
+    readonly verticalAlignment?: VerticalAlignmentType;
+}
+/** */
+export declare type InsertImageOptions = ImageOptions;
+interface ImagePartEntry {
+    readonly partName: PartName;
+    readonly relationshipId: RelationshipId;
+    readonly relationshipType: string;
+    /** Package content type (PNG/JPEG for authoring; other image/* on open). */
+    contentType: string;
+    data: Uint8Array;
+    dirty: boolean;
+    pendingRelationship: OpcRelationship | undefined;
+}
+interface ImageInit {
+    readonly relationshipId: string;
+    /** Display width in points (`wp:extent/@cx` EMU at host boundary). */
+    readonly width: number;
+    /** Display height in points (`wp:extent/@cy` EMU at host boundary). */
+    readonly height: number;
+    readonly name?: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly lockAspectRatio?: boolean;
+    readonly rotation?: number;
+    readonly flipHorizontal?: boolean;
+    readonly flipVertical?: boolean;
+    readonly placement?: PicturePlacementType;
+    readonly wrapping?: TextWrappingStyleType;
+    readonly horizontalOrigin?: HorizontalOriginType;
+    readonly verticalOrigin?: VerticalOriginType;
+    readonly horizontalPosition?: number;
+    readonly verticalPosition?: number;
+    readonly horizontalAlignment?: HorizontalAlignmentType;
+    readonly verticalAlignment?: VerticalAlignmentType;
+    readonly docPrId?: number;
+    readonly preservedHost?: OpenXmlElement;
+    readonly layoutDirty?: boolean;
+    /** DrawingML picture hyperlink relationship id (`a:hlinkClick/@r:id`). */
+    readonly hyperlinkRelationshipId?: string;
+    /** Runtime target URI for picture-backed hyperlinks (not serialized on the picture part). */
+    readonly hyperlinkTarget?: string;
+}
+/**
+ * DrawingML picture leaf in a paragraph (`w:r/w:drawing` with `wp:inline`
+ * or `wp:anchor` + `pic:pic`).
+ *
+ * Setting {@link Image.textWrappingStyle} to a non-inline value promotes the host
+ * to `wp:anchor`. Setting wrapping back to `'inline'` collapses to `wp:inline`
+ * and **drops** anchor position/wrap residual by design — see TSDoc on
+ * {@link Image.textWrappingStyle}.
+ *
+ * @public
+ */
+export declare class Picture implements FeatureRunLeaf {
+    /**
+     * Public discriminant for {@link Paragraph.items} ({@link EntityType.Picture}).
+     * @public
+     */
+    readonly type: EntityType.Picture;
+    private relationshipIdValue;
+    /** Display width in points. */
+    private widthValue;
+    /** Display height in points. */
+    private heightValue;
+    private nameValue;
+    private titleValue;
+    private descriptionValue;
+    private lockAspectRatioValue;
+    private rotationValue;
+    private flipHorizontalValue;
+    private flipVerticalValue;
+    private placementValue;
+    private wrappingValue;
+    private horizontalOriginValue;
+    private verticalOriginValue;
+    private horizontalPositionValue;
+    private verticalPositionValue;
+    private horizontalAlignmentValue;
+    private verticalAlignmentValue;
+    private docPrIdValue;
+    private preservedHostValue;
+    private layoutDirtyValue;
+    private hyperlinkRelationshipIdValue;
+    private hyperlinkTargetValue;
+    /**
+     * Create a picture bound to `document` for authoring.
+     *
+     * The instance is attached to the document host so {@link loadImage} and
+     * caption APIs resolve the images catalog. Append it with
+     * {@link Paragraph.appendImage} or by adding a feature-run item; call
+     * {@link loadImage} to supply media bytes before save.
+     *
+     * @example
+     * ```typescript
+     * const picture = new Picture(document);
+     * picture.loadImage(imageBytes);
+     * ```
+     *
+     * @param document - Owning {@link WordDocument}
+     * @public
+     */
+    constructor(document: WordDocument);
+    /** @private */
+    constructor(relationshipId: string, width: number, height: number);
+    /** @private */
+    constructor(init: ImageInit);
+    /** @private Build from decoded host state. */
+    static fromHostState(state: PictureHostState): Picture;
+    /** Display width in points (`wp:extent/@cx` EMU at host boundary). */
+    width: number;
+    /** Display height in points (`wp:extent/@cy` EMU at host boundary). */
+    height: number;
+    /**
+     * @private
+     * DrawingML picture hyperlink relationship id (`a:hlinkClick/@r:id`).
+     */
+    hyperlinkRelationshipId: string | undefined;
+    /**
+     * @private
+     * Runtime target URI for a picture-backed hyperlink. Not written to the
+     * picture DrawingML tree; the package relationship carries the target.
+     */
+    hyperlinkTarget: string | undefined;
+    /**
+     * @private
+     * Relationship id for the image media part; empty until materialized at save. */
+    readonly relationshipId: string;
+    /**
+     * Non-visual picture name (`wp:docPr/@name`, `pic:cNvPr/@name`).
+     * @defaultValue `'Picture'` on authoring.
+     */
+    name: string;
+    /**
+     * Caption / accessibility title (`wp:docPr/@title`).
+     * Not the same as {@link description} (`@descr`).
+     */
+    title: string | undefined;
+    /** Alternative text (`wp:docPr/@descr`). */
+    description: string | undefined;
+    /**
+     * Aspect-ratio lock (`a:graphicFrameLocks/@noChangeAspect`).
+     * Authoring default is `true`; missing locks on load read as `false`.
+     */
+    lockAspectRatio: boolean;
+    /**
+     * Clockwise rotation in degrees (`a:xfrm/@rot`).
+     * Wire uses ST_Angle = degrees × 60000.
+     */
+    rotation: number;
+    /** Horizontal flip (`a:xfrm/@flipH`). */
+    flipHorizontal: boolean;
+    /** Vertical flip (`a:xfrm/@flipV`). */
+    flipVertical: boolean;
+    /**
+     * Host placement (`wp:inline` vs `wp:anchor`).
+     * Prefer mutating {@link textWrappingStyle}; non-inline wrapping forces anchored.
+     */
+    placement: PicturePlacementType;
+    /**
+     * Text wrapping style.
+     *
+     * - `'inline'` serializes as `wp:inline`. Collapsing an anchored picture to
+     *   inline **drops** position and wrap residual by design.
+     * - Other values promote to `wp:anchor` with the matching wrap element.
+     *   Tight/through without a residual wrapPolygon fall back to `wrapNone`
+     *   (library does not invent polygons).
+     *
+     * @throws RangeError when `value` is not a known {@link TextWrappingStyle}.
+     */
+    textWrappingStyle: TextWrappingStyleType;
+    /**
+
+     */
+    /**
+
+    */
+    wrapping: TextWrappingStyleType;
+    /** Horizontal origin (`wp:positionH/@relativeFrom`). */
+    horizontalOrigin: HorizontalOriginType | undefined;
+    /** Vertical origin (`wp:positionV/@relativeFrom`). */
+    verticalOrigin: VerticalOriginType | undefined;
+    /**
+     * Horizontal offset (`wp:positionH/wp:posOffset`).
+     * Setting this clears {@link horizontalAlignment} (align XOR posOffset).
+     */
+    horizontalPosition: number | undefined;
+    /**
+     * Vertical offset (`wp:positionV/wp:posOffset`).
+     * Setting this clears {@link verticalAlignment} (align XOR posOffset).
+     */
+    verticalPosition: number | undefined;
+    /**
+     * Horizontal alignment (`wp:positionH/wp:align`).
+     * Setting this clears {@link horizontalPosition} (align XOR posOffset).
+     *
+     * @throws RangeError when `value` is not a known {@link HorizontalAlignment}.
+     */
+    horizontalAlignment: HorizontalAlignmentType | undefined;
+    /**
+     * Vertical alignment (`wp:positionV/wp:align`).
+     * Setting this clears {@link verticalPosition} (align XOR posOffset).
+     *
+     * @throws RangeError when `value` is not a known {@link VerticalAlignment}.
+     */
+    verticalAlignment: VerticalAlignmentType | undefined;
+    /** @private */
+    isPendingRelationship(): boolean;
+    /** @private */
+    resolveRelationshipId(relationshipId: string): void;
+    /** @private Apply optional authoring fields from {@link ImageOptions}. */
+    applyAppendOptions(options: ImageOptions): void;
+    /**
+     * Add a Word-style caption paragraph next to this picture.
+     *
+     * Creates a separate caption paragraph (built-in `Caption` style, centered,
+     * spacing 30/240 twips) containing a `SEQ <captionName> \* <switch>` complex
+     * field (ECMA-376-1 §17.16.5.56), inserted immediately before
+     * ({@link CaptionPosition.Above}) or after ({@link CaptionPosition.Below})
+     * the paragraph containing this picture. The picture and its paragraph are not
+     * moved or modified. The initial field result is the next number in the
+     * caption-name sequence; Microsoft Word remains authoritative on refresh.
+     *
+     * @returns The new caption {@link Paragraph}; append additional caption text
+     * or adjust its formatting on the returned object.
+     * @throws DocxError `content/invalid-caption-name` when the name is empty or
+     * whitespace-only.
+     * @throws DocxError `content/invalid-caption-format` /
+     * `content/invalid-caption-position` for unknown enum values.
+     * @throws DetachedObjectError when this picture is not attached to a paragraph
+     * in a main document body.
+     */
+    addCaption(captionName: string, numberingFormat: CaptionNumberingFormat, position: CaptionPosition): Paragraph;
+    /**
+     * Load image bytes into this picture instance.
+     *
+     * Loads image content into the current `Picture` instance, supporting:
+     * - Newly created pictures
+     * - Pictures loaded from existing documents
+     *
+     * If the picture already contains image data, calling `loadImage()` replaces
+     * the existing image with the newly supplied image bytes. The replacement
+     * occurs within the same `Picture` instance — no remove-and-add operation
+     * is required.
+     *
+     * The Picture instance remains attached to its parent container after image
+     * replacement. Parent references, collection indexes, and existing object
+     * references remain unchanged. Only the underlying image data is replaced.
+     *
+     * @example
+     * ```typescript
+     * // Load image into a newly created picture
+     * const picture = new Picture(document);
+     * picture.loadImage(imageBytes);
+     *
+     * // Replace existing picture content (same instance / collection index)
+     * const picture = paragraph.items[0] as Picture;
+     * picture.loadImage(newImageBytes);
+     * ```
+     *
+     * @param imageBytes - Image data as `Uint8Array` (PNG or JPEG)
+     * @throws DocxError when the picture is not attached to a document
+     * @public
+     */
+    loadImage(imageBytes: Uint8Array): void;
+    /**
+     * @private
+    */
+    toOpenXml(): OpenXmlElement;
+}
+/**
+ * Image media parts linked from the Main Document.
+ *
+ * @private
+ */
+export declare class ImagesCatalog implements FeatureMultiPackagePart {
+    private readonly entries;
+    private readonly byRelationshipId;
+    private readonly pendingRemovals;
+    private readonly pendingImages;
+    /** @private */
+    constructor(entries: Map<PartName, ImagePartEntry>);
+    /** @private */
+    removeEntry(relationshipId: string): void;
+    /** @private */
+    isDirty(): boolean;
+    /** @private */
+    applyToPackage(pkg: OpcPackage, mainPartName: PartName): OpcPackage;
+    /** Image bytes for a loaded relationship id. */
+    bytesForRelationship(relationshipId: string): Uint8Array | undefined;
+    /** @private Pending picture bytes before save-time materialization. */
+    pendingBytesFor(picture: Picture): Uint8Array | undefined;
+    /** @private Record picture intent without allocating package ids. */
+    registerPendingImage(picture: Picture, bytes: Uint8Array, contentType: ImageType): void;
+    /** @private Drop a pending picture that was removed before save. */
+    discardPendingImage(picture: Picture): void;
+    /** @private Replace bytes on a not-yet-materialized picture. */
+    updatePendingBytes(picture: Picture, bytes: Uint8Array): void;
+    /** @private */
+    materializePending(document: WordDocument): void;
+    /** @private */
+    pendingRelationshipIds(): ReadonlyArray<string>;
+    /** @private */
+    pendingPartNames(): ReadonlyArray<PartName>;
+    /** @private */
+    allocatePart(data: Uint8Array, contentType: ImageType, usedRelIds: ReadonlySet<string>, usedPartNames: ReadonlySet<string>): {
+        entry: ImagePartEntry;
+        relationshipId: string;
+    };
+    /** @private */
+    replaceBytes(relationshipId: string, data: Uint8Array): void;
+    /**
+     * Bind every inline picture in the main story to this document after body parse
+     * so {@link Picture.loadImage} works when pictures are taken from
+     * {@link Paragraph.items} without a prior {@link picturesInParagraph} walk.
+     *
+     * Invoked from {@link WordDocument.fromPackage} via duck-typed
+     * `afterMainDocumentLoad` (same pattern as comments).
+     *
+     * @private
+     */
+    afterMainDocumentLoad(document: WordDocument): void;
+}
+/** @private Test hook */
+export declare function resetImagesFeatureForTests(): void;
+/** @private Register the images multi-part and inline drawing handlers. Idempotent. */
+export declare function registerImagesFeature(): void;
+/**
+ * Image media catalog for a document.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the module was not registered before load.
+ * @private
+ */
+export declare function imagesFor(document: WordDocument): ImagesCatalog;
+/**
+ * Inline pictures in a paragraph, in document order (including nested inline content controls).
+ *
+ * @private
+ */
+export declare function picturesInParagraph(paragraph: Paragraph): ReadonlyArray<Picture>;
+/**
+
+ * @private
+ */
+export declare function imagesInParagraph(paragraph: Paragraph): ReadonlyArray<Picture>;
+/**
+ * Inline picture bytes for a picture relationship.
+ * @private
+ */
+export declare function inlinePictureBytes(document: WordDocument, picture: Picture): Uint8Array | undefined;
+/**
+
+ * @private
+ */
+export declare function inlineImageBytes(document: WordDocument, image: Picture): Uint8Array | undefined;
+/**
+ * Replace picture media bytes without changing layout markup.
+ * @private
+ */
+export declare function replaceInlinePictureBytes(document: WordDocument, picture: Picture, bytes: Uint8Array): void;
+/**
+
+ * @private
+ */
+export declare function replaceInlineImageBytes(document: WordDocument, image: Picture, bytes: Uint8Array): void;
+/**
+ * Remove an inline picture run from its paragraph and drop its media on the next save.
+ * @private
+ */
+export declare function removeInlinePicture(document: WordDocument, paragraph: Paragraph, picture: Picture): void;
+/**
+
+ * @private
+ */
+export declare function removeInlineImage(document: WordDocument, paragraph: Paragraph, image: Picture): void;
+/**
+ * Whether a paragraph item is a modeled inline picture from this module.
+ *
+ * @private
+ */
+export declare function isPictureLeaf(item: ParagraphItem | Picture): item is (FeatureRunParagraphItem & {
+    value: Picture;
+}) | Picture;
+/**
+
+ * @private
+ */
+export declare function isImageLeaf(item: ParagraphItem | Picture): item is (FeatureRunParagraphItem & {
+    value: Picture;
+}) | Picture;
+/**
+
+ * @public
+ */
+export declare type Image = Picture;