@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.10

package/types/src/group/Group.d.ts

@@ -0,0 +1,136 @@
+import { ITransaction } from '../transaction';
+import { IResource } from '../resource';
+import { ITextFrame } from '../text';
+import { IFill } from '../fill';
+import { IMovable, IMovableCollection } from '../movable';
+import { MovableContentRegistry } from '../movable/MovableContentRegistry';
+import { AbstractMovableContent } from '../movable/AbstractMovableContent';
+import { GroupMember } from '../movable/GroupMember';
+import { FrameRect } from '../movable/_DrawnBounds';
+import { InsertableCollection } from '../movable/_InsertableCollection';
+import { IGroup } from './IGroup';
+/** The group's own JSON: everything but the members, which are models of their own. */
+type GroupData = Omit<IGroup.JSON, 'members' | 'name'>;
+interface State extends AbstractMovableContent.State {
+    data: GroupData;
+    /** The members in z-order. */
+    members: readonly GroupMember[];
+}
+/**
+ * Implementation for {@link IGroup}.
+ */
+export declare class Group extends AbstractMovableContent<State, IGroup.JSON, IGroup.Events> implements IGroup {
+    private _members;
+    private _createOptions;
+    /** What each member asked to be told, for as long as the member lives: an undo can restore it. */
+    private _memberCallbacks;
+    /** The member order the members were last told of. */
+    private _toldOrder;
+    constructor(options: MovableContentRegistry.CreateOptions);
+    /** {@inheritDoc IModel.getType} */
+    getType(): string;
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
+    getTypeDescription(): string;
+    /** {@inheritDoc MovableContentRegistry.Content.getMovables} */
+    getMovables(): IMovableCollection;
+    /** The child space the members' placements are stated in: the file's, else the frame at the origin. */
+    private _childBounds;
+    /**
+     * Fits the group to its members after one of them changed, as Excel does: the child space
+     * becomes the union of the members' boxes (each frame with its sides swapped within 45 degrees of a
+     * quarter turn), growing or shrinking, and the frame follows it at the scale the group has, so
+     * no member moves on the canvas and a stretched group stays stretched.
+     */
+    private _rebound;
+    /** Where the group is drawn; `null` before it is laid out. */
+    private _drawnPlacement;
+    /** {@inheritDoc IGroup.getFill} */
+    getFill(): IFill.JSON | null;
+    /** {@inheritDoc IGroup.getTextFrame} */
+    getTextFrame(): ITextFrame.IText | null;
+    /**
+     * {@inheritDoc IMovable.IContent.acceptRotation}
+     *
+     * @remarks
+     * A group turns only when every member can: Excel will not turn a group that holds a chart or a
+     * control. A member that can turn still turns on its own.
+     */
+    get acceptRotation(): ((degrees: number) => number) | undefined;
+    /**
+     * {@inheritDoc IMovable.IContent.acceptFlip}
+     *
+     * @remarks
+     * A group mirrors only when every member can, as for {@link acceptRotation}.
+     */
+    get acceptFlip(): ((flip: IMovable.Flip) => IMovable.Flip) | undefined;
+    /** Whether every member's content defines `capability`; a nested group asks its own. */
+    private _isEveryMember;
+    /** {@inheritDoc IGroup.ungroup} */
+    ungroup(options?: IMovable.OperationOptions): Promise<IMovable[]>;
+    /**
+     * Places a copy of each of `members` in the group's container where it is drawn - through one
+     * level - and in the group's place in the z-order, as Excel does, and answers them. The members
+     * themselves stay; the caller deletes the group.
+     */
+    private _free;
+    /**
+     * {@inheritDoc IMovable.IContent.getConnections}
+     *
+     * @remarks
+     * A group has none: Excel glues a connector to a member of a group, never to the group.
+     */
+    getConnections(): readonly IMovable.Connection[];
+    /** {@inheritDoc Movable.Content.toJSON} */
+    toJSON(toResourceId?: (resource: IResource) => number | null): IGroup.JSON;
+    /**
+     * What the group paints in its `width` by `height` frame: the union of its members' drawn
+     * boxes, each placed in the frame.
+     * @internal
+     */
+    _getDrawnRect(width: number, height: number, onReady: () => void): FrameRect | null;
+    /** The members in z-order. @internal */
+    _getMembers(): readonly IMovable[];
+    private _members_;
+    /**
+     * Places a movable in the group.
+     * @internal
+     */
+    _addMember(options: IMovableCollection.AddOptions): Promise<IMovable>;
+    /**
+     * Places a movable whose content kind is already loaded in the group, without waiting.
+     * @internal
+     */
+    _insertMember(options: InsertableCollection.InsertOptions): IMovable;
+    /**
+     * Groups members of this group into a group of their own, inside it, as the sheet groups its
+     * movables: the new group's frame is the union of the boxes they occupy as rotated, its child
+     * space equals its frame, and each keeps its frame, rotation and flips. One undo step; the new
+     * group is selected unless `autoSelect` is `false`.
+     * @internal
+     */
+    _groupMembers(movables: readonly IMovable[], options?: IMovableCollection.GroupOptions): Promise<IMovable>;
+    /**
+     * Takes a member out. Down to one, the group dissolves, as Excel's does: the survivor is freed
+     * where it is drawn, as an ungroup frees it, in the same operation. The group goes with its last
+     * member.
+     */
+    private _removeMember;
+    /** Moves a member to `to` in the z-order. */
+    private _moveMember;
+    /** A member movable with its content, from its JSON. */
+    private _createMember;
+    /**
+     * Tells each member whose place in the order changed since the members were last told: by a
+     * move, or by an undo or a redo of one, which restores the order without moving anything.
+     */
+    private _tellZIndex;
+    /** Runs `callback` folded into the current commit. */
+    private _amend;
+    protected _processAfterStateChange(state: State, commit: ITransaction.ICommit): void;
+    /** {@inheritDoc IGroup.isIGroup} */
+    get isIGroup(): true;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=Group.d.ts.map

package/types/src/group/GroupMovableCollection.d.ts

@@ -0,0 +1,37 @@
+import { ITransaction } from '../transaction';
+import { AbstractCollection } from '../type';
+import { IResource, IResourceCollection } from '../resource';
+import { IMovable, IMovableCollection } from '../movable';
+import { InsertableCollection } from '../movable/_InsertableCollection';
+import { Group } from './Group';
+/**
+ * The members of a group: an {@link IMovableCollection} whose container is the group.
+ *
+ * @remarks
+ * Members answer canvas placements, but the collection keeps no spatial index: the cell filters
+ * of a sheet's collection (`address`, `bounds`) are not applied; `type`, `ignoreHidden` and
+ * `deep` are.
+ */
+export declare class GroupMovableCollection extends AbstractCollection<IMovable, IMovableCollection.GetItemsOptions> implements IMovableCollection, InsertableCollection {
+    private readonly _group;
+    constructor(_group: Group, transactions?: ITransaction.IStore);
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(options?: IMovableCollection.GetItemsOptions): IMovable[];
+    /** {@inheritDoc ICollection.getCount} */
+    getCount(): number;
+    /** {@inheritDoc IMovableCollection.add} */
+    add(options?: IMovableCollection.AddOptions): Promise<IMovable>;
+    /** {@inheritDoc InsertableCollection._insertNow} */
+    _insertNow(options: InsertableCollection.InsertOptions): IMovable;
+    /** {@inheritDoc IMovableCollection.addPicture} */
+    addPicture(picture: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions): Promise<IMovable>;
+    /** {@inheritDoc IMovableCollection.group} */
+    group(movables: readonly IMovable[], options?: IMovableCollection.GroupOptions): Promise<IMovable>;
+    /** {@inheritDoc IMovableCollection.updateSelected} */
+    updateSelected(update: (movable: IMovable) => void, action?: string): void;
+    /** Announces that the members changed. @internal */
+    _notifyChange(): void;
+    /** {@inheritDoc IMovableCollection.isIMovableCollection} */
+    get isIMovableCollection(): true;
+}
+//# sourceMappingURL=GroupMovableCollection.d.ts.map

package/types/src/group/IGroup.d.ts

@@ -0,0 +1,129 @@
+import { Bounds } from '@sheetxl/utils';
+import { ITransaction } from '../transaction';
+import { IResource } from '../resource';
+import { IModel } from '../model';
+import { IMovable } from '../movable';
+import { IFill, IEffect } from '../fill';
+import { IHyperlink } from '../hyperlink';
+import { ITextFrame } from '../text';
+import { IShape } from '../shape';
+/**
+ * A group: a movable that holds movables.
+ *
+ * @remarks
+ * A group is the content of an {@link IMovable} — `movable.getContent<IGroup>()` for a movable
+ * whose content type is `'group'`. Its members are ordinary movables, each with its own content
+ * (a shape, a picture, a chart, another group), held by the group's movable in z-order
+ * ({@link IMovable.getMovables}). A member's {@link IMovable.getParent} is the group's movable.
+ *
+ * A member is read and edited where it is drawn, like any movable; the group keeps its
+ * placement in the child space the file states ({@link IGroup.JSON.childBounds}) and maps it
+ * through its own frame. Resizing the group changes its frame only: the members keep what they
+ * store, and are drawn at the new scale, as Excel's Size pane shows it.
+ *
+ * @example
+ * ```ts
+ * for (const member of movable.getMovables()?.getItems() ?? []) {
+ *   console.log(member.getContent().getName?.(), member.getBounds());
+ * }
+ * ```
+ */
+export interface IGroup extends IModel, IMovable.IContent {
+    toJSON(toResourceId?: (resource: IResource) => number | null): IGroup.JSON;
+    /**
+     * Returns the name of the group.
+     */
+    getName(): string | null;
+    /**
+     * Returns the text written on the members, in z-order.
+     *
+     * @returns `null` when no member has a text body at all.
+     */
+    getTextFrame(): ITextFrame.IText | null;
+    /**
+     * The fill the group states for members that take the group's fill, or `null` for none.
+     */
+    getFill(): IFill.JSON | null;
+    /**
+     * Dissolves the group: each member is placed in the group's container where it is drawn, and
+     * the group is deleted.
+     *
+     * @returns The freed movables, in z-order.
+     *
+     * @remarks
+     * One level: a nested group is freed as a group. One undo step. A group whose last member is
+     * deleted is deleted with it.
+     *
+     * The freed movables are selected unless `autoSelect` is `false`.
+     */
+    ungroup(options?: IMovable.OperationOptions): Promise<IMovable[]>;
+    /**
+     * Deletes the group and its members, and with them the movable that places the group.
+     */
+    delete(options?: ITransaction.OperationOptions): void;
+    /** For runtime type checking. */
+    readonly isIGroup: true;
+}
+/**
+ * {@inheritDoc IGroup}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IGroup}
+ */
+export declare namespace IGroup {
+    /**
+     * A JSON representation useful for persistence.
+     */
+    interface JSON {
+        /**
+         * The name of the group.
+         */
+        name?: string;
+        /**
+         * The child space (`chOff`/`chExt`), in pixels: what the members' anchors are stated in,
+         * mapped onto the group's frame by a scale per axis. Absent, the group's frame at the origin.
+         *
+         * @remarks
+         * A group made from a selection has a child space equal to its frame; resizing the group
+         * afterwards leaves it as it was.
+         */
+        childBounds?: Bounds;
+        /**
+         * The members in z-order. A member is an ordinary movable whose anchor is absolute in the
+         * child space: `anchor.tl` its top-left and `anchor.br` its size, with no cells.
+         */
+        members?: IMovable.JSON[];
+        /**
+         * The fill members that take the group's fill draw with (`grpSpPr`). A nested group may itself
+         * take its group's fill.
+         */
+        fill?: IFill.SolidJSON | IFill.GradientJSON | IFill.PatternJSON | IFill.ImageJSON | IFill.NoneJSON | IFill.GroupJSON;
+        /**
+         * The group's effects (`grpSpPr/effectLst`).
+         */
+        effects?: IEffect.JSON[];
+        /** The 3-D scene (`grpSpPr/scene3d`) as the file states it: an opaque DrawingML fragment. */
+        scene3d?: string;
+        /** Extension lists kept as the file states them, by the element each extends. */
+        extLst?: IShape.ExtLstJSON;
+        /** The hyperlink on the whole group (`cNvPr/hlinkClick`). */
+        hyperlink?: IHyperlink.JSON;
+        /** The hyperlink followed on hover (`cNvPr/hlinkHover`). */
+        hoverHyperlink?: IHyperlink.JSON;
+        /** The title (`cNvPr/@title`), beside the description. */
+        title?: string;
+        /**
+         * Edit locks (`grpSpLocks`) by the file's own names: `noGrp`, `noUngrp`, `noSelect`, `noRot`,
+         * `noChangeAspect`, `noMove`, `noResize`.
+         */
+        locks?: Record<string, boolean>;
+        /**
+         * The id the file gave the group (`cNvPr/@id`). Kept and written again, as a shape's is.
+         */
+        sourceId?: number;
+    }
+    interface Events extends IMovable.ContentEvents {
+    }
+}
+//# sourceMappingURL=IGroup.d.ts.map

package/types/src/group/index.d.ts

@@ -0,0 +1,2 @@
+export * from './IGroup';
+//# sourceMappingURL=index.d.ts.map

package/types/src/history/IHistory.d.ts

@@ -22,8 +22,9 @@ export declare namespace IHistory {
      * @template S The type of the source for `getSource``.
      * @template C The type of the coordinates the snapshot is bound to.
      * @template J The type of the JSON for `toJSON`.
+     * @template R What `copyTo` resolves with; the coordinates unless the source has more to report.
      */
-    interface ISnapshot<D = any, S = any, C = any, J = any> {
+    interface ISnapshot<D = any, S = any, C = any, J = any, R = C> {
         /**
          * Copies the snapshot to the specified range.
          *
@@ -32,7 +33,7 @@ export declare namespace IHistory {
          *
          * @returns A promise that resolves when the copy is complete, or `void` if no asynchronous operation is required.
          */
-        copyTo(destination: D, options?: IHistory.CopyToOptions): Promise<C> | C;
+        copyTo(destination: D, options?: IHistory.CopyToOptions): Promise<R> | R;
         /**
          * The source that created the snapshot.
          * This is used to quickly do comparisons.

package/types/src/hyperlink/IHyperlink.d.ts

@@ -1,3 +1,4 @@
+import { ITransaction } from '../transaction';
 /**
  * Represents a hyperlink for linking to either a URL or a cell address.
  */
@@ -54,6 +55,10 @@ export interface IHyperlink {
      * otherwise `_blank`.
      */
     getTarget(): string;
+    /**
+     * Removes the link from the cell it is attached to. The cell's text stays.
+     */
+    delete(options?: ITransaction.OperationOptions): void;
     /**
      * For runtime type checking.
      */
@@ -89,6 +94,14 @@ export declare namespace IHyperlink {
         screenTip?: string;
         /** {@inheritDoc IHyperlink.getTarget} */
         target?: string;
+        /**
+         * An action the link performs instead of, or beside, following its address, as a file states
+         * it (`hlinkClick/@action`). Office's own (`ppaction://…`) mean nothing in a workbook; kept so
+         * the file reads back as written.
+         */
+        action?: string;
+        /** Whether following the link adds it to the browsing history (`hlinkClick/@history`). */
+        history?: boolean;
     }
     /**
      * A JSON representation useful for persistence.

package/types/src/hyperlink/_Hyperlink.d.ts

@@ -1,4 +1,5 @@
 import { ITypes } from '../type';
+import { ITransaction } from '../transaction';
 import { IHyperlink } from './IHyperlink';
 /**
  * `true` for an address the browser hands to another application (`mailto:`, `tel:`, `sms:`)
@@ -10,7 +11,10 @@ export declare class Hyperlink implements IHyperlink {
     protected _t: () => string;
     protected _p: IHyperlink.Properties;
     protected _r: (address: string, options: ITypes.SelectOptions | null, target: string, features?: string) => Promise<boolean>;
-    constructor(textToDisplay: () => string, resolver: (address: string, options: ITypes.SelectOptions | null, target: string, features?: string) => Promise<boolean>, json: IHyperlink.JSON);
+    protected _d: ((options?: ITransaction.OperationOptions) => void) | undefined;
+    constructor(textToDisplay: () => string, resolver: (address: string, options: ITypes.SelectOptions | null, target: string, features?: string) => Promise<boolean>, json: IHyperlink.JSON, remover?: (options?: ITransaction.OperationOptions) => void);
+    /** {@inheritDoc IHyperlink.delete} */
+    delete(options?: ITransaction.OperationOptions): void;
     /** {@inheritDoc IHyperlink.open} */
     open(target?: '_self' | '_blank', features?: string): Promise<boolean>;
     /** {@inheritDoc IHyperlink.getTarget} */

package/types/src/i18n/LanguagePack.d.ts

@@ -1,5 +1,5 @@
 import { FormulaError } from '@sheetxl/primitives';
-import { MinifiedDescriptor } from '@sheetxl/scripting';
+import { MinifiedDescriptor, MinifiedEnumDescriptors } from '@sheetxl/scripting';
 import { LanguagePack as BaseLanguagePack, LanguageTag } from '@sheetxl/utils';
 /**
  * The **spreadsheet-language plane** of a language pack (I18N-DESIGN.md Plane 3): function names,
@@ -56,10 +56,18 @@ export interface LanguagePack extends BaseLanguagePack {
      * descriptor. Values are {@link MinifiedDescriptor}s — the SAME shape the built-in
      * descriptor modules compile to, so a generated per-locale module IS a pack chunk with
      * no reshaping; `initializeFunctions` overlays it per-field over the built-in English.
+     *
+     * The module form may also carry `enums` — the copy for enum parameters, again the shape the
+     * descriptor modules compile to. A key is an enum id (`MatchMode`), which serves every function
+     * that declares an enum of that name, or `FUNCTION:EnumId` (`TEXTAFTER:MatchMode`) for the one
+     * function where the same name means something else. The qualified entry wins, per field.
      */
-    functionHelp?: () => Promise<Record<string, MinifiedDescriptor> | {
-        default: Record<string, MinifiedDescriptor>;
-    }>;
+    functionHelp?: () => Promise<Record<string, MinifiedDescriptor> | FunctionHelpModule>;
+}
+/** The module form of a {@link LanguagePack.functionHelp} chunk. */
+export interface FunctionHelpModule {
+    default: Record<string, MinifiedDescriptor>;
+    enums?: MinifiedEnumDescriptors;
 }
 /**
  * The active (or `tag`'s) spreadsheet-language pack — the MERGE of every contributor's plane: the

package/types/src/index.d.ts

@@ -22,6 +22,7 @@ export * from './text';
 export * from './condition';
 export * from './sort';
 export * from './filter';
+export * from './person';
 export * from './comment';
 export * from './hyperlink';
 export * from './numFmt';
@@ -30,7 +31,10 @@ export * from './resource';
 export * from './string';
 export * from './anchored';
 export * from './chart';
+export * from './pivot';
 export * from './picture';
+export * from './shape';
+export * from './group';
 export * from './scripting';
 export * from './calculation';
 export * from './address';
@@ -50,6 +54,7 @@ export * from './table';
 export { Table } from './table/Table';
 export * from './theme';
 export * from './sheet';
+export * from './outline';
 export * from './sheetHeader';
 export * from './sheetProtection';
 export * from './sheetView';

package/types/src/io/AbstractBackingStore.d.ts

@@ -16,6 +16,28 @@ export declare abstract class AbstractBackingStore implements IWorkbookIO.IBacki
     abstract write(request: IWorkbookIO.WriteRequest): Promise<IWorkbookIO.Origin | null>;
     /** @inheritdoc IWorkbookIO.IBackingStore.read */
     read(request: IWorkbookIO.ReadRequest): Promise<IWorkbook | null>;
+    /**
+     * The origin of an open workbook that saves back to the file being read, or `null`.
+     *
+     * @remarks
+     * Whether two sources are the same file is store knowledge — two stores never share a file. The
+     * base compares paths with {@link findOpenPath}; a store whose sources are handles rather than
+     * paths (the browser) overrides this.
+     */
+    protected findOpenOrigin(_acquired: any, info: IWorkbookIO.ReadInfo): Promise<IWorkbookIO.Origin | null>;
+    /**
+     * The origin of an open workbook that saves back to `path`, other than `except`, or `null`. Only a
+     * writable origin counts: a read-only one (a URL, a copy) never writes the file.
+     */
+    protected findOpenPath(path: string, except?: IWorkbookIO.Origin): IWorkbookIO.Origin | null;
+    /** Whether two paths name the same file. Exact by default; a store knows its file system's rules. */
+    protected isSamePath(a: string, b: string): boolean;
+    /**
+     * Reads a writable file handle (for example a browser `FileSystemFileHandle` from an open picker
+     * or a drop) into its `File`, or returns `null` when the source is not one. A source read this way
+     * mints a writable origin. The base implementation recognizes no handles.
+     */
+    protected fileFromHandle(_source: any): Promise<File | null>;
     /**
      * Resolves a source when {@link AbstractBackingStore.read} is called without one — for example
      * a browser open picker. The base implementation resolves nothing.
@@ -23,7 +45,8 @@ export declare abstract class AbstractBackingStore implements IWorkbookIO.IBacki
     protected resolveSource(_request: IWorkbookIO.ReadRequest): Promise<any>;
     /**
      * Hook invoked after a workbook has been read, so a subclass can associate session state with
-     * it (e.g. cache an opened file handle for silent save-back). The base implementation is a no-op.
+     * it (e.g. cache an opened file handle for silent save-back). `source` is the source as acquired —
+     * the handle itself, not the `File` read from it. The base implementation is a no-op.
      */
     protected onWorkbookRead(_workbook: IWorkbook, _source: any): Promise<void>;
     /**

package/types/src/io/ArrayBackingStore.d.ts

@@ -27,7 +27,7 @@ export declare class ArrayBackingStore implements IWorkbookIO.IBackingStore {
      */
     get buffer(): ArrayBufferLike | null;
     /** @inheritdoc IWorkbookIO.IBackingStore.write */
-    write(request: IWorkbookIO.WriteRequest): Promise<IWorkbookIO.Origin>;
+    write(request: IWorkbookIO.WriteRequest): Promise<IWorkbookIO.Origin | null>;
     /** @inheritdoc IWorkbookIO.IBackingStore.read */
     read(request: IWorkbookIO.ReadRequest): Promise<IWorkbook | null>;
 }

package/types/src/io/EmbeddedPart.d.ts

@@ -0,0 +1,20 @@
+import { IResource } from '../resource';
+import { IEmbeddedPart } from './IEmbeddedPart';
+/**
+ * Reading and writing an {@link IEmbeddedPart} tree, shared by every model that carries one.
+ *
+ * @internal
+ */
+export declare namespace EmbeddedPart {
+    /**
+     * A carried part with its content resolved back to the resource holding it.
+     *
+     * @remarks
+     * A part whose content no longer resolves is carried without it rather than dropped: the markup
+     * that references it is still there, and dropping the part would leave that reference dangling,
+     * which is the one failure this whole subtree exists to prevent.
+     */
+    const fromJSON: (json: IEmbeddedPart.JSON | undefined, fromResourceId?: (resourceId: number) => IResource) => IEmbeddedPart | null;
+    const toJSON: (part: IEmbeddedPart | null, toResourceId?: (resource: IResource) => number | null) => IEmbeddedPart.JSON | null;
+}
+//# sourceMappingURL=EmbeddedPart.d.ts.map

package/types/src/io/IEmbeddedPart.d.ts

@@ -0,0 +1,63 @@
+import { IResource } from '../resource';
+/**
+ * A document part carried on the model, together with the parts its own markup references.
+ *
+ * @remarks
+ * Some of what a spreadsheet contains is not one part but a small tree of them. A chart's markup
+ * names a style definition, a color definition, the shapes drawn on top of it, sometimes a whole
+ * embedded workbook holding its data; a form control names the part describing what kind of control
+ * it is. Each is named by relationship id, so a reference that does not come back makes the
+ * document unreadable rather than merely plainer. The whole subtree is carried rather than an
+ * enumerated few of it, which is what makes that impossible: nothing referenced can be missing,
+ * whether or not this version knows what it was for.
+ *
+ * The same shape describes every level, `id` and `type` being the edge from the part that
+ * references it.
+ */
+export interface IEmbeddedPart {
+    /** The relationship id the referencing markup cites this part by. */
+    id: string;
+    /** The relationship type URI. */
+    type: string;
+    /**
+     * The markup, for a part that has any.
+     *
+     * @remarks
+     * Opaque: held as it was read and replayed unchanged, since what it describes has no model yet.
+     */
+    xml?: string;
+    /** The content, for a part that is not markup — an embedded workbook, an image. */
+    resource?: IResource;
+    /**
+     * The content type.
+     *
+     * @remarks
+     * Carried because it cannot be derived: `style1.xml` and `colors1.xml` are both `.xml` and are
+     * different types, and a reader that gets this wrong is handed a part it cannot interpret.
+     */
+    contentType?: string;
+    /** What the part was called where it was read from, so it can be called that again. */
+    name?: string;
+    /** The parts this one's markup references. */
+    parts?: IEmbeddedPart[];
+}
+/**
+ * {@inheritDoc IEmbeddedPart}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IEmbeddedPart}
+ */
+export declare namespace IEmbeddedPart {
+    /** {@link IEmbeddedPart} as JSON — its content by {@link IResource} id. */
+    interface JSON {
+        id: string;
+        type: string;
+        xml?: string;
+        resId?: number;
+        contentType?: string;
+        name?: string;
+        parts?: JSON[];
+    }
+}
+//# sourceMappingURL=IEmbeddedPart.d.ts.map