allyhub 0.4.0 → 0.6.0

package/dist/node_modules/@allyhub-next/slides-core/dist/api.d.ts

@@ -0,0 +1,706 @@
+import type { Numbering, AnimationEffect, AnimationFile, LineDash, TransitionFile, LineEnd, ShapeGeometry, TextAlign, ThemeColor } from "@allyhub-next/formats";
+import type { Anchor, AutoSize, FillType, PlaceholderType, ShapeType } from "./enums.js";
+import type { Color, ComponentContext, DeckDef, FontDef, Frame, GradientDef, FreeformPath, GeneratedSlideDef, GeneratorContext, LayoutDef, MasterDef, ParagraphDef, TableCellDef, TableDef, ParagraphFormatDef, PropSpec, RunDef, ShapeDef, TextFrameDef } from "./model.js";
+import type { SheetChartType } from "@allyhub-next/formats";
+import { Chart, type CategoryChartData, type XyChartData } from "./chart-api.js";
+import type { ThemeInput } from "./theme.js";
+import { type Length, type SlideSizeName } from "./units.js";
+/** python-pptx's `RGBColor(r, g, b)` and `RGBColor.from_string("3C2F80")`: a colour as `#RRGGBB`. */
+export declare const RGBColor: ((r: number, g: number, b: number) => string) & {
+    from_string: (s: string) => string;
+};
+/** A colour (python-pptx's `ColorFormat`): the theme's, or RGB. */
+export declare class ColorFormat {
+    private readonly read;
+    private readonly write;
+    constructor(read: () => Color | undefined, write: (c: Color | undefined) => void);
+    get theme_color(): ThemeColor | undefined;
+    set theme_color(c: ThemeColor | undefined);
+    /** `#RRGGBB`; python-pptx's `RGBColor`, here a string (RGBColor(…) makes one). */
+    get rgb(): string | undefined;
+    set rgb(v: string | undefined);
+}
+/** Character properties (python-pptx's `Font`). */
+export declare class Font {
+    private readonly def;
+    constructor(def: FontDef);
+    private _set;
+    /** A line through it (PowerPoint's Strikethrough). */
+    get strike(): boolean | undefined;
+    set strike(v: boolean | undefined);
+    /** Raised or lowered, a share of its size: superscript 0.3, subscript -0.25. */
+    get baseline(): number | undefined;
+    set baseline(v: number | undefined);
+    /** The colour behind it, as RGBColor gives one. */
+    get highlight(): string | undefined;
+    set highlight(v: string | undefined);
+    get name(): string | undefined;
+    set name(v: string | undefined);
+    get size(): Length | undefined;
+    set size(v: Length | undefined);
+    get bold(): boolean | undefined;
+    set bold(v: boolean | undefined);
+    get italic(): boolean | undefined;
+    set italic(v: boolean | undefined);
+    /** A single underline or none (python-pptx also takes MSO_UNDERLINE's kinds). */
+    get underline(): boolean | undefined;
+    set underline(v: boolean | undefined);
+    /** Space added between letters, a Length (negative tightens): PowerPoint's Character Spacing, which python-pptx has no name for. */
+    get spacing(): Length | undefined;
+    set spacing(v: Length | undefined);
+    get color(): ColorFormat;
+}
+/** python-pptx's `_Run`. */
+/** python-pptx's `_Hyperlink`: what a run opens. */
+export declare class Hyperlink {
+    private readonly def;
+    constructor(def: RunDef);
+    get address(): string | undefined;
+    set address(v: string | undefined);
+}
+export declare class Run {
+    private readonly def;
+    constructor(def: RunDef);
+    get text(): string;
+    set text(v: string);
+    get font(): Font;
+    get hyperlink(): Hyperlink;
+}
+/** What a paragraph and a list style's level share: alignment, spacing, its runs' font. */
+declare abstract class Format {
+    protected abstract readonly fmt: ParagraphFormatDef;
+    protected _set<K extends keyof ParagraphFormatDef>(k: K, v: ParagraphFormatDef[K] | undefined): void;
+    get alignment(): TextAlign | undefined;
+    set alignment(v: TextAlign | undefined);
+    /** A number of lines (1.5), or a Length (Pt(18)) for a fixed height. */
+    get line_spacing(): number | undefined;
+    set line_spacing(v: number | undefined);
+    get space_before(): Length | undefined;
+    set space_before(v: Length | undefined);
+    get space_after(): Length | undefined;
+    set space_after(v: Length | undefined);
+    /** Its runs' default character properties (`a:defRPr`). */
+    get font(): Font;
+}
+/** python-pptx's `_Paragraph`. */
+export declare class Paragraph extends Format {
+    protected readonly fmt: ParagraphDef;
+    constructor(def: ParagraphDef);
+    /** Its runs' text, a line break as `\v`. */
+    get text(): string;
+    /** Its runs replaced; `\n` and `\v` are line breaks (a new paragraph is text_frame.text's `\n`). */
+    set text(v: string);
+    get runs(): Run[];
+    add_run(): Run;
+    add_line_break(): void;
+    /** Its runs and line breaks removed, its properties kept. */
+    clear(): this;
+    get level(): number;
+    set level(v: number);
+}
+/**
+ * A level of a list style (an extension: `a:lvlNpPr` of a text frame's
+ * `a:lstStyle` or a master's text styles): what a paragraph at that level
+ * takes when it does not set it, with its bullet and its indents.
+ */
+export declare class ListLevel extends Format {
+    protected readonly fmt: ParagraphFormatDef;
+    constructor(def: ParagraphFormatDef);
+    /** Counted in place of a bullet (`a:buAutoNum`): "arabicPeriod", "alphaLcPeriod"… */
+    get numbered(): Numbering | undefined;
+    set numbered(v: Numbering | undefined);
+    /** Its bullet character, or null for none (`a:buChar`, `a:buNone`). */
+    get bullet(): string | null | undefined;
+    set bullet(v: string | null | undefined);
+    get bullet_font(): string | undefined;
+    set bullet_font(v: string | undefined);
+    /** Where its lines start (`@marL`). */
+    get margin_left(): Length | undefined;
+    set margin_left(v: Length | undefined);
+    /** Its first line from margin_left (`@indent`; negative hangs it, for a bullet). */
+    get indent(): Length | undefined;
+    set indent(v: Length | undefined);
+}
+/** A list style's nine levels, level 0 first. */
+export type ListStyle = readonly [
+    ListLevel,
+    ListLevel,
+    ListLevel,
+    ListLevel,
+    ListLevel,
+    ListLevel,
+    ListLevel,
+    ListLevel,
+    ListLevel
+];
+/** python-pptx's `TextFrame`. */
+export declare class TextFrame {
+    private readonly def;
+    constructor(def: TextFrameDef);
+    private _set;
+    /** Its paragraphs' text joined by `\n`, a line break as `\v`. */
+    get text(): string;
+    /** Every paragraph replaced: a paragraph per `\n`, a line break per `\v`. */
+    set text(v: string);
+    /** Its paragraphs; a text frame always has one. */
+    get paragraphs(): Paragraph[];
+    add_paragraph(): Paragraph;
+    /** Every paragraph but the first removed, and the first emptied, its properties kept. */
+    clear(): void;
+    /**
+     * python-pptx's `fit_text`: here the frame shrinks its text to fit when
+     * it is drawn (MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE), from max_size points.
+     */
+    fit_text(font_family?: string, max_size?: number, bold?: boolean, italic?: boolean): void;
+    /** Its list style's nine levels (an extension: `a:lstStyle`), level 0 first: what its paragraphs take. */
+    get list_style(): ListStyle;
+    get vertical_anchor(): Anchor | undefined;
+    set vertical_anchor(v: Anchor | undefined);
+    get auto_size(): AutoSize | undefined;
+    set auto_size(v: AutoSize | undefined);
+    get word_wrap(): boolean | undefined;
+    set word_wrap(v: boolean | undefined);
+    get margin_left(): Length;
+    set margin_left(v: Length);
+    get margin_top(): Length;
+    set margin_top(v: Length);
+    get margin_right(): Length;
+    set margin_right(v: Length);
+    get margin_bottom(): Length;
+    set margin_bottom(v: Length);
+}
+/** python-pptx's `FillFormat`, for a solid fill and none. */
+export declare class FillFormat {
+    private readonly read;
+    private readonly write;
+    private readonly start;
+    /** The shape it fills: only a shape's has a gradient and a transparency. */
+    private readonly shape;
+    constructor(read: () => Color | null | undefined, write: (v: Color | null) => void, start?: Color, shape?: ShapeDef);
+    /** A solid fill; its colour is fore_color. */
+    solid(): void;
+    /** No fill (python-pptx's `background()`: transparent). */
+    background(): void;
+    private _shape;
+    /** A gradient fill, of two of the theme's colours until gradient_stops says otherwise. */
+    gradient(): void;
+    /** A gradient's degrees, clockwise from left to right. python-pptx's run the other way. */
+    get gradient_angle(): number;
+    set gradient_angle(v: number);
+    /** A gradient's stops: `[{ at, color, transparency }]`, `at` and `transparency` shares. */
+    get gradient_stops(): GradientDef["stops"];
+    set gradient_stops(v: GradientDef["stops"]);
+    private _gradient;
+    /** How much of the fill shows through, a share (PowerPoint's Transparency). */
+    get transparency(): number;
+    set transparency(v: number);
+    /** MSO_FILL.SOLID, MSO_FILL.BACKGROUND, MSO_FILL.GRADIENT, or undefined while it is inherited. */
+    get type(): FillType | undefined;
+    /** A solid fill's colour; python-pptx refuses it for another fill: call solid() first. */
+    get fore_color(): ColorFormat;
+}
+/**
+ * python-pptx's `ShadowFormat`: a shape's shadow. Its `inherit` is there; what
+ * a shadow is made of, python-pptx has no API for.
+ */
+export declare class ShadowFormat {
+    private readonly def;
+    constructor(def: ShapeDef);
+    private _shadow;
+    /** Whether it has none of its own; false gives it SHADOW_DEFAULTS. */
+    get inherit(): boolean;
+    set inherit(v: boolean);
+    get blur_radius(): Length;
+    set blur_radius(v: Length);
+    get distance(): Length;
+    set distance(v: Length);
+    get angle(): number;
+    set angle(v: number);
+    get transparency(): number;
+    set transparency(v: number);
+    get color(): ColorFormat;
+}
+/** python-pptx's `LineFormat`: a shape's outline. */
+export declare class LineFormat {
+    private readonly def;
+    constructor(def: ShapeDef);
+    /** Its colour; setting one makes the line solid. */
+    get color(): ColorFormat;
+    get fill(): FillFormat;
+    get width(): Length;
+    set width(v: Length);
+    /** Its dashes (MSO_LINE), or null for its theme's. */
+    get dash_style(): LineDash | null;
+    set dash_style(v: LineDash | null);
+    /** What the end of the line where it starts has (MSO_ARROWHEAD). */
+    get begin_arrow(): LineEnd;
+    set begin_arrow(v: LineEnd);
+    /** What the end of the line where it ends has (MSO_ARROWHEAD). */
+    get end_arrow(): LineEnd;
+    set end_arrow(v: LineEnd);
+}
+/** python-pptx's `_Background` of a slide, a layout or a master. */
+export declare class Background {
+    private readonly holder;
+    constructor(holder: {
+        background?: Color | undefined;
+    });
+    get fill(): FillFormat;
+}
+/** A geometry's adjustments and what each is when not set (PresentationML's presets). */
+export declare const ADJUSTMENT_DEFAULTS: Partial<Record<ShapeGeometry, number[]>>;
+/** python-pptx's `Adjustments`: `shape.adjustments[0] = 0.1`. */
+export declare class Adjustments {
+    [i: number]: number;
+    private readonly def;
+    constructor(def: ShapeDef);
+    private _values;
+    get length(): number;
+    /** Sets an adjustment (python-pptx's `adjustments[i] = value`). */
+    _set(i: number, v: number): void;
+}
+/** A shape (python-pptx's `Shape`, `Picture`, `Movie`, `Connector`, a placeholder alike). */
+export declare class Shape {
+    private readonly def;
+    /** The frame it takes while it has none of its own: its master's or its layout's placeholder's. */
+    private readonly inherit;
+    constructor(def: ShapeDef, inherit?: () => Frame | undefined);
+    /** The model it writes (this package's). */
+    get _def(): ShapeDef;
+    private _frame;
+    private _own;
+    get name(): string;
+    set name(v: string);
+    get shape_type(): ShapeType;
+    get is_placeholder(): boolean;
+    get has_table(): boolean;
+    get has_chart(): boolean;
+    /** A chart (python-pptx's GraphicFrame.chart). */
+    get chart(): Chart;
+    /** A table's cells, columns and rows (python-pptx's GraphicFrame.table). */
+    get table(): Table;
+    get placeholder_format(): {
+        type: PlaceholderType;
+        idx: number;
+    };
+    get left(): Length;
+    set left(v: Length);
+    get top(): Length;
+    set top(v: Length);
+    get width(): Length;
+    set width(v: Length);
+    get height(): Length;
+    set height(v: Length);
+    /** Degrees clockwise about its centre; python-pptx's, kept from 0 up to 360. */
+    get rotation(): number;
+    set rotation(v: number);
+    get has_text_frame(): boolean;
+    get text_frame(): TextFrame;
+    /** Its text frame's text (python-pptx's `shape.text`). */
+    get text(): string;
+    set text(v: string);
+    get fill(): FillFormat;
+    get line(): LineFormat;
+    get shadow(): ShadowFormat;
+    /** Its geometry's adjustments: `adjustments[0] = 0.1` sets a rounded rectangle's corner. */
+    get adjustments(): Adjustments;
+}
+/**
+ * python-pptx's `FreeformBuilder`: an outline drawn in local units from a
+ * start, `scale` EMU to a unit (a number, or `[x, y]`), and made a shape by
+ * convert_to_shape(). Segments are straight, as python-pptx's, or curved
+ * (add_curve_segment, an extension).
+ */
+export declare class FreeformBuilder {
+    private readonly steps;
+    private readonly sx;
+    private readonly sy;
+    private readonly make;
+    constructor(start: [number, number], scale: number | readonly [number, number], make: (path: FreeformPath, frame: Frame) => Shape);
+    /** Straight segments to each vertex, and back to the start of this outline unless `close` is false. */
+    add_line_segments(vertices: Iterable<readonly [number, number]>, close?: boolean): this;
+    /** A cubic Bézier segment to a point, by its two control points (`a:cubicBezTo`). */
+    add_curve_segment(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this;
+    /** Lifts the pen: the next segment starts here, a contour of its own. */
+    move_to(x: number, y: number): this;
+    /** The outline as a shape, its local origin at this place on the slide. */
+    convert_to_shape(origin_x?: Length, origin_y?: Length): Shape;
+}
+/**
+ * python-pptx's `GroupShape`: its shapes move as one in PowerPoint. It is
+ * its shapes, listed with the shapes it is among and drawn as they are;
+ * its box is theirs. A group holds no group: the file's are read flat.
+ */
+export declare class GroupShape {
+    private readonly list;
+    private _name;
+    private readonly make;
+    constructor(list: ShapeDef[], name: string, make: (name: string) => ShapeCollection);
+    private members;
+    private box;
+    /** The shapes in it; what is added to them is in it. */
+    get shapes(): ShapeCollection;
+    get shape_type(): ShapeType;
+    get name(): string;
+    set name(v: string);
+    get left(): Length;
+    /** Moves its shapes with it. */
+    set left(v: Length);
+    get top(): Length;
+    /** Moves its shapes with it. */
+    set top(v: Length);
+    get width(): Length;
+    get height(): Length;
+}
+/** python-pptx's `_Cell`. */
+export declare class Cell {
+    private readonly def;
+    private readonly table;
+    private readonly row;
+    private readonly col;
+    constructor(def: TableCellDef, table: TableDef, row: number, col: number);
+    get text_frame(): TextFrame;
+    get text(): string;
+    set text(v: string);
+    get fill(): FillFormat;
+    /** Its edges, each a colour and a width; python-pptx has none (`a:lnL`…). */
+    get borders(): NonNullable<TableCellDef["borders"]>;
+    set borders(v: NonNullable<TableCellDef["borders"]>);
+    get margin_left(): Length;
+    set margin_left(v: Length);
+    get margin_right(): Length;
+    set margin_right(v: Length);
+    get margin_top(): Length;
+    set margin_top(v: Length);
+    get margin_bottom(): Length;
+    set margin_bottom(v: Length);
+    get vertical_anchor(): Anchor | undefined;
+    set vertical_anchor(v: Anchor | undefined);
+    get is_merge_origin(): boolean;
+    get is_spanned(): boolean;
+    get span_width(): number;
+    get span_height(): number;
+    /** Merges this cell and another, and those between, into the first of them. */
+    merge(other: Cell): void;
+    /** Takes a merge this cell starts apart. */
+    split(): void;
+}
+/** python-pptx's `_Column`. */
+export declare class Column {
+    private readonly def;
+    private readonly at;
+    constructor(def: TableDef, at: number);
+    get width(): Length;
+    set width(v: Length);
+}
+/** python-pptx's `_Row`. */
+export declare class Row {
+    private readonly def;
+    private readonly at;
+    constructor(def: TableDef, at: number);
+    private get row();
+    get height(): Length;
+    set height(v: Length);
+}
+/** python-pptx's `Table`. */
+export declare class Table {
+    private readonly def;
+    constructor(def: TableDef);
+    cell(row_idx: number, col_idx: number): Cell;
+    iter_cells(): Iterable<Cell>;
+    get columns(): Column[];
+    get rows(): Row[];
+    private flag;
+    get first_row(): boolean;
+    set first_row(v: boolean);
+    get first_col(): boolean;
+    set first_col(v: boolean);
+    get last_row(): boolean;
+    set last_row(v: boolean);
+    get last_col(): boolean;
+    set last_col(v: boolean);
+    get horz_banding(): boolean;
+    set horz_banding(v: boolean);
+    get vert_banding(): boolean;
+    set vert_banding(v: boolean);
+}
+/** python-pptx's `SlideShapes` (and a master's, a layout's), with its `add_*` methods. */
+export declare class ShapeCollection implements Iterable<Shape> {
+    /** python-pptx's `shapes[i]`, back to front. */
+    readonly [i: number]: Shape | undefined;
+    private readonly list;
+    /** The folder of the module that writes the deck, a project path: paths are from it. */
+    private readonly base;
+    private readonly components;
+    private readonly inherit;
+    /** The group these are in, when they are a group's. */
+    private readonly group;
+    /** The shapes drawn under these (a layout's master's; a slide's layout's and master's): a new name is none of theirs. */
+    private readonly under;
+    constructor(list: ShapeDef[], base: string, components: () => Readonly<Record<string, unknown>>, inherit?: (s: ShapeDef) => Frame | undefined, under?: () => readonly ShapeDef[], group?: string);
+    private _wrap;
+    private _at;
+    [Symbol.iterator](): Iterator<Shape>;
+    /** python-pptx's `len(shapes)`. */
+    get length(): number;
+    /** A shape by its name (an extension). */
+    get(name: string): Shape | undefined;
+    /** Its title placeholder (python-pptx's `shapes.title`). */
+    get title(): Shape | undefined;
+    /** Its placeholders (python-pptx's `shapes.placeholders`). */
+    get placeholders(): Placeholders;
+    private _add;
+    /** A text box, as python-pptx makes one: it does not wrap, and the shape fits its text. */
+    add_textbox(left: Length, top: Length, width: Length, height: Length): Shape;
+    /** A picture; python-pptx takes its own size when width or height is left out, which needs the file: here both are given. */
+    add_picture(image_file: string, left: Length, top: Length, width?: Length, height?: Length): Shape;
+    /** A video file; its poster is a moment of it, in seconds. */
+    add_movie(movie_file: string, left: Length, top: Length, width: Length, height: Length, options?: {
+        poster_frame_time?: number;
+    }): Shape;
+    /** An autoshape, as python-pptx makes one: filled and outlined in accent 1, its text light 1, centred. */
+    add_shape(autoshape_type_id: ShapeGeometry, left: Length, top: Length, width: Length, height: Length): Shape;
+    /** A table of equal columns and rows (python-pptx's add_table), in `.table`; unlike python-pptx's it has no style, so its look is its cells'. */
+    add_table(rows: number, cols: number, left: Length, top: Length, width: Length, height: Length): Shape;
+    /** A chart (python-pptx's add_chart), in `.chart`; PowerPoint opens it as its own, with its numbers in a workbook. */
+    add_chart(chart_type: SheetChartType, x: Length, y: Length, cx: Length, cy: Length, chart_data: CategoryChartData | XyChartData): Shape;
+    /** A group of shapes (python-pptx's add_group_shape): what is added to its `shapes` is in it. */
+    add_group_shape(): GroupShape;
+    /** A freeform's builder (python-pptx's build_freeform): filled and outlined as an autoshape. */
+    build_freeform(start_x?: number, start_y?: number, scale?: number | readonly [number, number]): FreeformBuilder;
+    /** A straight line from one point to another (MSO_CONNECTOR.STRAIGHT). */
+    add_connector(connector_type: ShapeGeometry, begin_x: Length, begin_y: Length, end_x: Length, end_y: Length): Shape;
+    /** A component of the presentation (`prs.components.add`), drawn by its code in the frame (an extension). */
+    add_component(component: string, left: Length, top: Length, width: Length, height: Length, props?: Record<string, unknown>): Shape;
+}
+/** The name a placeholder of a type has when it is given none. */
+export declare const NAME_OF_TYPE: Record<PlaceholderType, string>;
+/** A master's, a layout's or a slide's placeholders: python-pptx's `placeholders`, indexed by idx. */
+export declare class Placeholders implements Iterable<Shape> {
+    /** python-pptx's `placeholders[idx]`, by idx. */
+    readonly [idx: number]: Shape | undefined;
+    private readonly list;
+    private readonly inherit;
+    constructor(list: ShapeDef[], inherit?: (s: ShapeDef) => Frame | undefined);
+    private _wrap;
+    [Symbol.iterator](): Iterator<Shape>;
+    get length(): number;
+    /** A placeholder by its idx (python-pptx's `get(idx)`), or by its name or type (a master's `get(ph_type)`). */
+    get(key: number | string): Shape | undefined;
+    /**
+     * A placeholder of a type, in a frame or (on a layout) in its master's
+     * of its type (an extension: python-pptx reads them from a template).
+     * Its name is the type's (`title`, `subtitle`, `body`, `picture`…)
+     * unless given; its idx is PowerPoint's (a title 0, a date, footer and
+     * slide number 10, 11, 12, the rest from 1).
+     */
+    add(type: PlaceholderType, options?: {
+        name?: string;
+    }): Shape;
+    add(type: PlaceholderType, left: Length, top: Length, width: Length, height: Length, options?: {
+        name?: string;
+    }): Shape;
+}
+/** What a master and its layouts share: the deck's folder, its components. */
+interface Context {
+    base: string;
+    components: () => Readonly<Record<string, unknown>>;
+}
+/** python-pptx's `SlideLayout`. */
+export declare class SlideLayout {
+    private readonly def;
+    private readonly master;
+    private readonly ctx;
+    constructor(def: LayoutDef, master: SlideMaster, ctx: Context);
+    get _def(): LayoutDef;
+    /** The frame a placeholder of it takes while it has none: its master's of its type. */
+    private inherit;
+    get name(): string;
+    get slide_master(): SlideMaster;
+    /** Whether its master's shapes are drawn on its slides (PowerPoint's Hide Background Graphics, turned round). */
+    get display_master_shapes(): boolean;
+    set display_master_shapes(v: boolean);
+    get background(): Background;
+    get placeholders(): Placeholders;
+    get shapes(): ShapeCollection;
+}
+/** python-pptx's `SlideLayouts`: a master's, by position (`slide_layouts[0]`). */
+export declare class SlideLayouts implements Iterable<SlideLayout> {
+    /** python-pptx's `slide_layouts[i]`. */
+    readonly [i: number]: SlideLayout | undefined;
+    private readonly list;
+    private readonly make;
+    constructor(list: SlideLayout[], make?: (name: string) => SlideLayout);
+    [Symbol.iterator](): Iterator<SlideLayout>;
+    get length(): number;
+    get_by_name(name: string, default_?: SlideLayout): SlideLayout | undefined;
+    index(slide_layout: SlideLayout): number;
+    /** A new layout on this master (an extension). */
+    add(name: string, build?: (layout: SlideLayout) => void): SlideLayout;
+}
+/** A master's text styles (an extension: `p:txStyles`), each nine levels: its titles', its other placeholders', other text's. */
+export declare class TextStyles {
+    private readonly def;
+    constructor(def: MasterDef["text_styles"]);
+    get title_style(): ListStyle;
+    get body_style(): ListStyle;
+    get other_style(): ListStyle;
+}
+/** python-pptx's `SlideMaster`. */
+export declare class SlideMaster {
+    private readonly def;
+    private readonly layouts;
+    private readonly ctx;
+    private readonly allLayouts;
+    constructor(def: MasterDef, ctx: Context, allLayouts: SlideLayout[]);
+    get _def(): MasterDef;
+    get name(): string;
+    get background(): Background;
+    get placeholders(): Placeholders;
+    get shapes(): ShapeCollection;
+    /** Its text styles, Office's to start with (an extension). */
+    get text_styles(): TextStyles;
+    get slide_layouts(): SlideLayouts;
+}
+/** python-pptx's `SlideMasters`, by position (`slide_masters[0]`), with `add` (an extension). */
+export declare class SlideMasters implements Iterable<SlideMaster> {
+    /** python-pptx's `slide_masters[i]`. */
+    readonly [i: number]: SlideMaster | undefined;
+    private readonly list;
+    private readonly make;
+    constructor(list: SlideMaster[], make: (name: string) => SlideMaster);
+    [Symbol.iterator](): Iterator<SlideMaster>;
+    get length(): number;
+    index(slide_master: SlideMaster): number;
+    /** A new master, with Office's text styles and no placeholders yet (an extension). */
+    add(name: string, build?: (master: SlideMaster) => void): SlideMaster;
+}
+/** A slide a generator makes (python-pptx's `Slide`): its layout's placeholders to fill, shapes to add, its notes. */
+export declare class GeneratedSlide {
+    private readonly own;
+    private readonly def;
+    private readonly layout;
+    constructor(def: GeneratedSlideDef, layout: SlideLayout, ctx: Context);
+    private readonly _shapes;
+    private readonly _placeholders;
+    get shapes(): ShapeCollection;
+    get placeholders(): Placeholders;
+    /** Its id in its block (python-pptx's is a number). */
+    get slide_id(): string;
+    get slide_layout(): SlideLayout;
+    get has_notes_slide(): boolean;
+    get notes_slide(): {
+        notes_text_frame: {
+            text: string;
+        };
+    };
+    /** What the slide holds, as data (this package's). */
+    /** How it comes on from the slide before (python-pptx has none). */
+    get transition(): TransitionFile | undefined;
+    set transition(v: TransitionFile | undefined);
+    /** Its Animation Pane, in order (python-pptx has none): `add(shape, effect, options)`. */
+    get animations(): Animations;
+    _done(): GeneratedSlideDef;
+}
+/** A generated slide's Animation Pane. */
+export declare class Animations {
+    private readonly list;
+    constructor(list: AnimationFile[]);
+    /** An animation of a shape (or its name), after the ones there. */
+    add(shape: Shape | string, effect: AnimationEffect, options?: Omit<AnimationFile, "shape" | "effect">): void;
+    get length(): number;
+}
+/** A generator's slides (python-pptx's `prs.slides`, for the slides it makes). */
+declare class GeneratedSlides {
+    private readonly gen;
+    constructor(gen: Generator);
+    /** A slide on a layout (an object, or a layout's name), with its id in the block. */
+    add_slide(slide_layout: SlideLayout | string, id: string): GeneratedSlide;
+}
+/** What a generator's function is given: the data and the slides it adds. */
+export declare class Generator {
+    private readonly list;
+    private readonly prs;
+    private readonly ctx;
+    constructor(prs: Presentation, ctx: GeneratorContext);
+    /** A data file (CSV rows, YAML, JSON) from the deck's folder. */
+    data(path: string): unknown;
+    get slides(): GeneratedSlides;
+    _add(slide_layout: SlideLayout | string, id: string): GeneratedSlide;
+    _made(): GeneratedSlideDef[];
+}
+/** A component as `prs.components.add` takes it. */
+export interface ComponentInput {
+    /** The props a person may change in the editor, by the SDK's prop types. */
+    props?: Readonly<Record<string, PropSpec>>;
+    /** Its layers, drawn in its frame (the layer contract: custom(), defineComponent()…). */
+    layers: (props: Record<string, unknown>, ctx: ComponentContext) => unknown[];
+}
+/** python-pptx's `Presentation`, as a deck's code is given it. */
+export declare class Presentation {
+    private readonly masters;
+    private readonly layouts;
+    private readonly def;
+    readonly _ctx: Context;
+    constructor(size: readonly [Length, Length], base: string);
+    get _def(): DeckDef;
+    get slide_width(): Length;
+    set slide_width(v: Length);
+    get slide_height(): Length;
+    set slide_height(v: Length);
+    get slide_masters(): SlideMasters;
+    /** The first master (python-pptx's `slide_master`). */
+    get slide_master(): SlideMaster;
+    /** The first master's layouts (python-pptx's); `get_by_name` finds one of any master with prs.slide_masters. */
+    get slide_layouts(): SlideLayouts;
+    /** python-pptx's slides are slides.yaml's here. */
+    get slides(): never;
+    save(): never;
+    /** The theme over the project's look (an extension: python-pptx reads it from a template). */
+    get theme(): ThemeInput;
+    set theme(v: ThemeInput);
+    /** Components: shapes drawn by code (an extension). */
+    get components(): {
+        add: (name: string, c: ComponentInput) => void;
+    };
+    /**
+     * Generators: slides made from data, which slides.yaml places as one
+     * block (`- id: stories, generate: name`) (an extension).
+     */
+    get generators(): {
+        add: (name: string, make: (g: Generator) => void) => void;
+    };
+    /** A layout of any master, by name. */
+    _layout(name: string): SlideLayout | undefined;
+}
+/** Marks a deck made by presentation(). */
+export declare const DECK_BRAND = "__allyhubDeck";
+export interface PresentationOptions {
+    /** Its name for people: what lists show it by. */
+    title?: string;
+    /** The slide size: a name (`16:9`, `4:3`, `a4`…) or `{ width, height }` in EMU; default 16:9. */
+    size?: SlideSizeName | {
+        width: Length;
+        height: Length;
+    };
+    /** The theme, over the project's look. */
+    theme?: ThemeInput;
+}
+/** A deck: the default export of an item's slides.ts. */
+export interface Deck {
+    readonly [DECK_BRAND]: true;
+    readonly kind: "slides";
+    readonly options: PresentationOptions;
+    readonly build: (prs: Presentation) => void;
+    /** The module that called presentation(), a project path ("" where it was not known). */
+    readonly written: {
+        file: string;
+    };
+}
+export declare function isDeck(v: unknown): v is Deck;
+/** presentation() for a module: its paths are from that module's folder. */
+export declare const presentationFor: (file: string) => (options: PresentationOptions | ((prs: Presentation) => void), build?: (prs: Presentation) => void) => Deck;
+/** The deck's definition, made by running its code. */
+export declare function evaluateDeck(deck: Deck): DeckDef;
+export {};
+//# sourceMappingURL=api.d.ts.map