/** * Math element. */ export declare class MathElement { type?: MathElement.TypeEnum; } export declare namespace MathElement { enum TypeEnum { Accent, Array, Bar, Block, BorderBox, Box, Delimiter, Text, Fraction, Function, GroupingCharacter, LeftSubSuperscriptElement, Limit, Matrix, NaryOperator, Radical, RightSubSuperscriptElement, SubscriptElement, SuperscriptElement, Phantom } } /** * Specifies the accent function, consisting of a base and a combining diacritical mark */ export declare class AccentElement extends MathElement { constructor(); /** * The argument to which the accent was applied */ base?: MathElement; /** * Accent Character */ character?: string; } export declare namespace AccentElement { } /** * A set of properties specifying which access permissions should be granted when the document is opened with user access. */ export declare class AccessPermissions { /** * The user may print the document (possibly not at the highest quality level, depending on whether bit HighQualityPrint is also set). */ printDocument: boolean; /** * The user may modify the contents of the document by operations other than those controlled by bits AddOrModifyFields, FillExistingFields, AssembleDocument. */ modifyContent: boolean; /** * The user may copy or otherwise extract text and graphics from the document by operations other than that controlled by bit ExtractTextAndGraphics. */ copyTextAndGraphics: boolean; /** * The user may add or modify text annotations, fill in interactive form fields, and, if bit ModifyContent is also set, create or modify interactive form fields (including signature fields). */ addOrModifyFields: boolean; /** * The user may fill in existing interactive form fields (including signature fields), even if bit AddOrModifyFields is clear. */ fillExistingFields: boolean; /** * The user may extract text and graphics in support of accessibility to users with disabilities or for other purposes. */ extractTextAndGraphics: boolean; /** * The user may assemble the document (insert, rotate, or delete pages and create bookmarks or thumbnail images), even if bit ModifyContent is clear. */ assembleDocument: boolean; /** * The user may print the document to a representation from which a faithful digital copy of the PDF content could be generated. When this bit is clear (and bit PrintDocument is set), printing is limited to a low-level representation of the appearance, possibly of degraded quality. */ highQualityPrint: boolean; } /** * Represents task for pipeline. */ export declare class Task { type?: Task.TypeEnum; } export declare namespace Task { enum TypeEnum { Save, SaveSlide, SaveShape, AddSlide, AddMasterSlide, AddLayoutSlide, RemoveSlide, ReoderSlide, Merge, UpdateBackground, ResetSlide, AddShape, RemoveShape, UpdateShape, ReplaceText } } /** * Add layout slide task. */ export declare class AddLayoutSlide extends Task { constructor(); /** * Source file. */ cloneFromFile?: InputFile; /** * Source layout slide position. */ cloneFromPosition: number; } export declare namespace AddLayoutSlide { } /** * Add master slide task. */ export declare class AddMasterSlide extends Task { constructor(); /** * Source presentation clone from. */ cloneFromFile?: InputFile; /** * Index of slide to clone. */ cloneFromPosition: number; /** * True if cloned master slide is applied to all slides. */ applyToAll: boolean; } export declare namespace AddMasterSlide { } /** * Add shape task. */ export declare class AddShape extends Task { constructor(); /** * Shape DTO. */ shape?: ShapeBase; /** * Shape path for a grouped shape or smart art shape. */ shapePath?: string; } export declare namespace AddShape { } /** * Add slide task. */ export declare class AddSlide extends Task { constructor(); /** * File to clone a slide from. */ cloneFromFile?: InputFile; /** * Position of the slide to clone. */ cloneFromPosition: number; /** * Position at which to insert the slide. */ position: number; /** * Alias of layout (href, index or type). If value is null a blank slide is added. */ layoutAlias?: string; } export declare namespace AddSlide { } /** * Image transform effect */ export declare class ImageTransformEffect { type?: ImageTransformEffect.TypeEnum; } export declare namespace ImageTransformEffect { enum TypeEnum { AlphaBiLevel, AlphaCeiling, AlphaFloor, AlphaInverse, AlphaModulate, AlphaModulateFixed, AlphaReplace, BiLevel, Blur, ColorChange, ColorReplace, Duotone, FillOverlay, GrayScale, Hsl, Luminance, Tint } } /** * Represents an Alpha Bi-Level effect. */ export declare class AlphaBiLevelEffect extends ImageTransformEffect { constructor(); /** * Returns effect threshold. */ threshold: number; } export declare namespace AlphaBiLevelEffect { } /** * Represents an Alpha Ceiling effect. */ export declare class AlphaCeilingEffect extends ImageTransformEffect { constructor(); } export declare namespace AlphaCeilingEffect { } /** * /// Represents an Alpha Floor effect. */ export declare class AlphaFloorEffect extends ImageTransformEffect { constructor(); } export declare namespace AlphaFloorEffect { } /** * Represents an Alpha Inverse effect. */ export declare class AlphaInverseEffect extends ImageTransformEffect { constructor(); } export declare namespace AlphaInverseEffect { } /** * Represents an Alpha Modulate effect. */ export declare class AlphaModulateEffect extends ImageTransformEffect { constructor(); } export declare namespace AlphaModulateEffect { } /** * Represents an Alpha Modulate Fixed effect. */ export declare class AlphaModulateFixedEffect extends ImageTransformEffect { constructor(); /** * Returns an amount of effect in percents. */ amount: number; } export declare namespace AlphaModulateFixedEffect { } /** * Represents an Alpha Replace Effect effect. */ export declare class AlphaReplaceEffect extends ImageTransformEffect { constructor(); /** * The new opacity value. */ alpha: number; } export declare namespace AlphaReplaceEffect { } /** * Represents response for ApiInfo DTO */ export declare class ApiInfo { /** * Product name. */ name?: string; /** * API version. */ version?: string; } /** * Represents segment of geometry path */ export declare class PathSegment { type?: PathSegment.TypeEnum; } export declare namespace PathSegment { enum TypeEnum { Close, MoveTo, LineTo, ArcTo, QuadBezierTo, CubicBezierTo } } /** * Arc segment of the geometry path */ export declare class ArcToPathSegment extends PathSegment { constructor(); /** * Width of the rectangle */ width: number; /** * Height of the rectangle */ height: number; /** * Start angle */ startAngle: number; /** * Sweep angle */ sweepAngle: number; } export declare namespace ArcToPathSegment { } /** * An array of elements. */ export declare class ArrayElement extends MathElement { constructor(); /** * Arguments */ arguments?: Array; /** * Specifies alignment of the array relative to surrounding text */ baseJustification?: ArrayElement.BaseJustificationEnum; /** * Maximum Distribution */ maximumDistribution?: boolean; /** * Object Distribution */ objectDistribution?: boolean; /** * The type of vertical spacing between array elements */ rowSpacingRule?: ArrayElement.RowSpacingRuleEnum; /** * Spacing between rows of an array */ rowSpacing?: number; } export declare namespace ArrayElement { enum BaseJustificationEnum { NotDefined, Top, Center, Bottom } enum RowSpacingRuleEnum { SingleLineGap, OneAndAHalfLineGap, TwoLineGap, Exactly, Multiple } } /** * Arrow head properties. */ export declare class ArrowHeadProperties { /** * Length. */ length?: ArrowHeadProperties.LengthEnum; /** * Style. */ style?: ArrowHeadProperties.StyleEnum; /** * Width. */ width?: ArrowHeadProperties.WidthEnum; } export declare namespace ArrowHeadProperties { enum LengthEnum { Short, Medium, Long, NotDefined } enum StyleEnum { None, Triangle, Stealth, Diamond, Oval, Open, NotDefined } enum WidthEnum { Narrow, Medium, Wide, NotDefined } } /** * Base class for all Slide's DTO objects */ export declare class ResourceBase { /** * Gets or sets the link to this resource. */ selfUri?: ResourceUri; /** * List of alternate links. */ alternateLinks?: Array; } /** * Slide shape. */ export declare class ShapeBase extends ResourceBase { constructor(); /** * Gets or sets the name. */ name?: string; /** * Gets or sets the width. */ width?: number; /** * Gets or sets the height. */ height?: number; /** * Gets or sets the alternative text. */ alternativeText?: string; /** * The title of alternative text associated with the shape. */ alternativeTextTitle?: string; /** * Gets or sets a value indicating whether this ShapeBase is hidden. */ hidden?: boolean; /** * Gets or sets 'Mark as decorative' option. */ isDecorative?: boolean; /** * Gets or sets the X */ x?: number; /** * Gets or sets the Y. */ y?: number; /** * Gets z-order position of shape */ zOrderPosition?: number; /** * Gets or sets the fill format. */ fillFormat?: FillFormat; /** * Gets or sets the effect format. */ effectFormat?: EffectFormat; /** * Gets or sets the 3D format */ threeDFormat?: ThreeDFormat; /** * Gets or sets the line format. */ lineFormat?: LineFormat; /** * Hyperlink defined for mouse click. */ hyperlinkClick?: Hyperlink; /** * Hyperlink defined for mouse over. */ hyperlinkMouseOver?: Hyperlink; type?: ShapeBase.TypeEnum; } export declare namespace ShapeBase { enum TypeEnum { Shape, Chart, Table, PictureFrame, VideoFrame, AudioFrame, SmartArt, OleObjectFrame, GroupShape, GraphicalObject, Connector, SmartArtShape, ZoomFrame, SectionZoomFrame, SummaryZoomFrame, SummaryZoomSection } } /** * Represents GeometryShape resource. */ export declare class GeometryShape extends ShapeBase { constructor(); /** * Combined shape type. */ shapeType: GeometryShape.ShapeTypeEnum; } export declare namespace GeometryShape { enum ShapeTypeEnum { Custom, Line, LineInverse, Triangle, RightTriangle, Rectangle, Diamond, Parallelogram, Trapezoid, NonIsoscelesTrapezoid, Pentagon, Hexagon, Heptagon, Octagon, Decagon, Dodecagon, FourPointedStar, FivePointedStar, SixPointedStar, SevenPointedStar, EightPointedStar, TenPointedStar, TwelvePointedStar, SixteenPointedStar, TwentyFourPointedStar, ThirtyTwoPointedStar, RoundCornerRectangle, OneRoundCornerRectangle, TwoSamesideRoundCornerRectangle, TwoDiagonalRoundCornerRectangle, OneSnipOneRoundCornerRectangle, OneSnipCornerRectangle, TwoSamesideSnipCornerRectangle, TwoDiagonalSnipCornerRectangle, Plaque, Ellipse, Teardrop, HomePlate, Chevron, PieWedge, Pie, BlockArc, Donut, NoSmoking, RightArrow, LeftArrow, UpArrow, DownArrow, StripedRightArrow, NotchedRightArrow, BentUpArrow, LeftRightArrow, UpDownArrow, LeftUpArrow, LeftRightUpArrow, QuadArrow, CalloutLeftArrow, CalloutRightArrow, CalloutUpArrow, CalloutDownArrow, CalloutLeftRightArrow, CalloutUpDownArrow, CalloutQuadArrow, BentArrow, UTurnArrow, CircularArrow, LeftCircularArrow, LeftRightCircularArrow, CurvedRightArrow, CurvedLeftArrow, CurvedUpArrow, CurvedDownArrow, SwooshArrow, Cube, Can, LightningBolt, Heart, Sun, Moon, SmileyFace, IrregularSeal1, IrregularSeal2, FoldedCorner, Bevel, Frame, HalfFrame, Corner, DiagonalStripe, Chord, CurvedArc, LeftBracket, RightBracket, LeftBrace, RightBrace, BracketPair, BracePair, StraightConnector1, BentConnector2, BentConnector3, BentConnector4, BentConnector5, CurvedConnector2, CurvedConnector3, CurvedConnector4, CurvedConnector5, Callout1, Callout2, Callout3, Callout1WithAccent, Callout2WithAccent, Callout3WithAccent, Callout1WithBorder, Callout2WithBorder, Callout3WithBorder, Callout1WithBorderAndAccent, Callout2WithBorderAndAccent, Callout3WithBorderAndAccent, CalloutWedgeRectangle, CalloutWedgeRoundRectangle, CalloutWedgeEllipse, CalloutCloud, Cloud, Ribbon, Ribbon2, EllipseRibbon, EllipseRibbon2, LeftRightRibbon, VerticalScroll, HorizontalScroll, Wave, DoubleWave, Plus, ProcessFlow, DecisionFlow, InputOutputFlow, PredefinedProcessFlow, InternalStorageFlow, DocumentFlow, MultiDocumentFlow, TerminatorFlow, PreparationFlow, ManualInputFlow, ManualOperationFlow, ConnectorFlow, PunchedCardFlow, PunchedTapeFlow, SummingJunctionFlow, OrFlow, CollateFlow, SortFlow, ExtractFlow, MergeFlow, OfflineStorageFlow, OnlineStorageFlow, MagneticTapeFlow, MagneticDiskFlow, MagneticDrumFlow, DisplayFlow, DelayFlow, AlternateProcessFlow, OffPageConnectorFlow, BlankButton, HomeButton, HelpButton, InformationButton, ForwardOrNextButton, BackOrPreviousButton, EndButton, BeginningButton, ReturnButton, DocumentButton, SoundButton, MovieButton, Gear6, Gear9, Funnel, PlusMath, MinusMath, MultiplyMath, DivideMath, EqualMath, NotEqualMath, CornerTabs, SquareTabs, PlaqueTabs, ChartX, ChartStar, ChartPlus, NotDefined } } /** * Represents AudioFrame resource. */ export declare class AudioFrame extends GeometryShape { constructor(); /** * Returns or sets a last track index. */ audioCdEndTrack?: number; /** * Returns or sets a last track time. */ audioCdEndTrackTime?: number; /** * Returns or sets a start track index. */ audioCdStartTrack?: number; /** * Returns or sets a start track time. */ audioCdStartTrackTime?: number; /** * Determines whether a sound is embedded to a presentation. */ embedded?: boolean; /** * Determines whether an AudioFrame is hidden. */ hideAtShowing?: boolean; /** * Determines whether an audio is looped. */ playLoopMode?: boolean; /** * Returns or sets the audio play mode. */ playMode?: AudioFrame.PlayModeEnum; /** * Returns or sets the audio volume. */ volume?: AudioFrame.VolumeEnum; /** * Audio volume percent. */ volumeValue?: number; /** * Audio data encoded in base64. */ base64Data?: string; /** * Determines whether an audio is playing across the slides. */ playAcrossSlides?: boolean; /** * Determines whether audio is automatically rewound to start after playing. */ rewindAudio?: boolean; /** * Time duration for the initial fade-in of the media in milliseconds. */ fadeInDuration?: number; /** * Time duration for the ending fade-out of the media in milliseconds. */ fadeOutDuration?: number; /** * Time duration to be removed from the beginning of the media during playback in milliseconds. */ trimFromStart?: number; /** * Time duration to be removed from the end of the media during playback in milliseconds. */ trimFromEnd?: number; /** * Picture fill format. */ pictureFillFormat?: PictureFill; } export declare namespace AudioFrame { enum PlayModeEnum { Auto, OnClick, AllSlides, InClickSequence, Mixed } enum VolumeEnum { Mute, Low, Medium, Loud, Mixed } } /** * Represents chart axes */ export declare class Axes { /** * Gets or sets the horizontal axis. */ horizontalAxis?: Axis; /** * Gets or sets the vertical axis. */ verticalAxis?: Axis; /** * Gets or sets the secondary horizontal axis. */ secondaryHorizontalAxis?: Axis; /** * Gets or sets the secondary vertical axis. */ secondaryVerticalAxis?: Axis; } /** * Represents a chart axis */ export declare class Axis { /** * True if the axis is visible */ isVisible?: boolean; /** * True if the axis has a visible title */ hasTitle?: boolean; /** * Axis title */ title?: ChartTitle; /** * Axis position */ position?: Axis.PositionEnum; /** * The scaling value of the display units for the value axis */ displayUnit?: Axis.DisplayUnitEnum; /** * The smallest time unit that is represented on the date axis */ baseUnitScale?: Axis.BaseUnitScaleEnum; /** * True the major unit of the axis is automatically assigned */ isAutomaticMajorUnit?: boolean; /** * The major units for the date or value axis */ majorUnit?: number; /** * The major unit scale for the date axis */ majorUnitScale?: Axis.MajorUnitScaleEnum; /** * The type of major tick mark for the specified axis */ majorTickMark?: Axis.MajorTickMarkEnum; /** * True the minor unit of the axis is automatically assigned */ isAutomaticMinorUnit?: boolean; /** * The minor units for the date or value axis */ minorUnit?: number; /** * The minor unit scale for the date axis */ minorUnitScale?: Axis.MinorUnitScaleEnum; /** * The type of minor tick mark for the specified axis */ minorTickMark?: Axis.MinorTickMarkEnum; /** * True if the max value is automatically assigned */ isAutomaticMaxValue?: boolean; /** * The maximum value on the value axis */ maxValue?: number; /** * True if the min value is automatically assigned */ isAutomaticMinValue?: boolean; /** * The minimum value on the value axis */ minValue?: number; /** * True if the value axis scale type is logarithmic */ isLogarithmic?: boolean; /** * The logarithmic base. Default value is 10 */ logBase?: number; /** * The type of the category axis */ categoryAxisType?: Axis.CategoryAxisTypeEnum; /** * True if the value axis crosses the category axis between categories. This property applies only to category axes, and it doesn't apply to 3-D charts */ axisBetweenCategories?: boolean; /** * The distance of labels from the axis. Applied to category or date axis. Value must be between 0% and 1000%. */ labelOffset?: number; /** * True if MS PowerPoint plots data points from last to first */ isPlotOrderReversed?: boolean; /** * True if the format is linked to source data */ isNumberFormatLinkedToSource?: boolean; /** * the format string for the Axis Labels */ numberFormat?: string; /** * The CrossType on the specified axis where the other axis crosses */ crossType?: Axis.CrossTypeEnum; /** * The point on the axis where the perpendicular axis crosses it */ crossAt?: number; /** * True for automatic tick marks spacing value */ isAutomaticTickMarksSpacing?: boolean; /** * Specifies how many tick marks shall be skipped before the next one shall be drawn. Applied to category or series axis. */ tickMarksSpacing?: number; /** * True for automatic tick label spacing value */ isAutomaticTickLabelSpacing?: boolean; /** * Specifies how many tick labels to skip between label that is drawn. */ tickLabelSpacing?: number; /** * The position of tick-mark labels on the specified axis. */ tickLabelPosition?: Axis.TickLabelPositionEnum; /** * Represents the rotation angle of tick labels. */ tickLabelRotationAngle?: number; /** * Get or sets the fill format. */ fillFormat?: FillFormat; /** * Get or sets the effect format. */ effectFormat?: EffectFormat; /** * Get or sets the line format. */ lineFormat?: LineFormat; /** * Get or sets the format of major grid lines. */ majorGridLinesFormat?: ChartLinesFormat; /** * Get or sets the format of major grid lines. */ minorGridLinesFormat?: ChartLinesFormat; } export declare namespace Axis { enum PositionEnum { Bottom, Left, Right, Top } enum DisplayUnitEnum { None, Hundreds, Thousands, TenThousands, HundredThousands, Millions, TenMillions, HundredMillions, Billions, Trillions, CustomValue } enum BaseUnitScaleEnum { None, Days, Months, Years } enum MajorUnitScaleEnum { None, Days, Months, Years } enum MajorTickMarkEnum { Cross, Inside, None, Outside } enum MinorUnitScaleEnum { None, Days, Months, Years } enum MinorTickMarkEnum { Cross, Inside, None, Outside } enum CategoryAxisTypeEnum { Text, Date } enum CrossTypeEnum { AxisCrossesAtZero, Maximum, Custom } enum TickLabelPositionEnum { High, Low, NextTo, None } } /** * Defines axis type. */ /** * Defines axis type. */ export declare enum AxisType { 'HorizontalAxis', 'VerticalAxis', 'SecondaryHorizontalAxis', 'SecondaryVerticalAxis' } /** * Specifies the bar function, consisting of a base argument and an overbar or underbar */ export declare class BarElement extends MathElement { constructor(); /** * Base */ base?: MathElement; /** * Position of the bar line. */ position?: BarElement.PositionEnum; } export declare namespace BarElement { enum PositionEnum { NotDefined, Top, Bottom } } /** * Represents abstract input file source for pipeline. */ export declare class InputFile { /** * Get or sets password to open document. */ password?: string; type?: InputFile.TypeEnum; } export declare namespace InputFile { enum TypeEnum { Path, Request, Base64 } } /** * Represents base64 inline encoded file. */ export declare class Base64InputFile extends InputFile { constructor(); /** * Get or sets base64 data. */ data?: string; } export declare namespace Base64InputFile { } /** * Represents an BiLevel effect. */ export declare class BiLevelEffect extends ImageTransformEffect { constructor(); /** * Returns effect threshold. */ threshold: number; } export declare namespace BiLevelEffect { } /** * Specifies an instance of mathematical text that contained within a MathParagraph and starts on its own line. */ export declare class BlockElement extends MathElement { constructor(); /** * List of math elements. */ mathElementList?: Array; } export declare namespace BlockElement { } /** * Represents blur effect */ export declare class BlurEffect { /** * radius */ radius: number; /** * true if the bounds are grown */ grow: boolean; } /** * Represents a Blur effect that is applied to the entire shape, including its fill. All color channels, including alpha, are affected. */ export declare class BlurImageEffect extends ImageTransformEffect { constructor(); /** * Returns or sets blur radius. */ radius: number; /** * Determines whether the bounds of the object should be grown as a result of the blurring. True indicates the bounds are grown while false indicates that they are not. */ grow: boolean; } export declare namespace BlurImageEffect { } /** * Rectangular or some other border around the MathElement. */ export declare class BorderBoxElement extends MathElement { constructor(); /** * Base */ base?: MathElement; /** * Hide Top Edge */ hideTop?: boolean; /** * Hide Bottom Edge */ hideBottom?: boolean; /** * Hide Left Edge */ hideLeft?: boolean; /** * Hide Right Edge */ hideRight?: boolean; /** * Strikethrough Horizontal */ strikethroughHorizontal?: boolean; /** * Strikethrough Vertical */ strikethroughVertical?: boolean; /** * Strikethrough Bottom-Left to Top-Right */ strikethroughBottomLeftToTopRight?: boolean; /** * Strikethrough Top-Left to Bottom-Right. */ strikethroughTopLeftToBottomRight?: boolean; } export declare namespace BorderBoxElement { } /** * Box element. */ export declare class BoxElement extends MathElement { constructor(); /** * Base */ base?: MathElement; /** * Operator emulator */ operatorEmulator?: boolean; /** * No break */ noBreak?: boolean; /** * Differential */ differential?: boolean; /** * Alignment point */ alignmentPoint?: boolean; /** * Explicit break */ explicitBreak?: number; } export declare namespace BoxElement { } /** * Data point. */ export declare class DataPoint { /** * Gets or sets the fill format. */ fillFormat?: FillFormat; /** * Gets or sets the effect format. */ effectFormat?: EffectFormat; /** * Gets or sets the 3D format */ threeDFormat?: ThreeDFormat; /** * Gets or sets the line format. */ lineFormat?: LineFormat; /** * Gets or sets the marker. */ marker?: SeriesMarker; type?: DataPoint.TypeEnum; } export declare namespace DataPoint { enum TypeEnum { OneValue, Scatter, Bubble } } /** * Scatter chart (two-dimensional) data point */ export declare class ScatterChartDataPoint extends DataPoint { constructor(); /** * X-value */ xValue?: number; /** * Y-value */ yValue?: number; /** * Spreadsheet formula in A1-style. */ xValueFormula?: string; /** * Spreadsheet formula in A1-style. */ yValueFormula?: string; } export declare namespace ScatterChartDataPoint { } /** * Bubble chart data point. */ export declare class BubbleChartDataPoint extends ScatterChartDataPoint { constructor(); /** * Bubble size. */ bubbleSize?: number; /** * Spreadsheet formula in A1-style. */ bubbleSizeFormula?: string; } export declare namespace BubbleChartDataPoint { } /** * A chart series. */ export declare class Series { /** * Series type. */ type?: Series.TypeEnum; /** * Series name. */ name?: string; /** * Series name data source. */ dataSourceForSeriesName?: DataSource; /** * True if each data marker in the series has a different color. */ isColorVaried?: boolean; /** * Invert solid color for the series. */ invertedSolidFillColor?: string; /** * True if curve smoothing is turned on. Applies only to line and scatter connected by lines charts. */ smooth?: boolean; /** * True if the series is plotted on second value axis. */ plotOnSecondAxis?: boolean; /** * Series order. */ order?: number; /** * True if the series shall invert its colors if the value is negative. Applies to bar, column and bubble series. */ invertIfNegative?: boolean; /** * The distance of an open pie slice from the center of the pie chart is expressed as a percentage of the pie diameter. */ explosion?: number; /** * Series marker. */ marker?: SeriesMarker; /** * Fill properties set for the series. */ fillFormat?: FillFormat; /** * Effect properties set for the series. */ effectFormat?: EffectFormat; /** * Line properties set for the series. */ lineFormat?: LineFormat; dataPointType?: Series.DataPointTypeEnum; } export declare namespace Series { enum TypeEnum { ClusteredColumn, StackedColumn, PercentsStackedColumn, ClusteredColumn3D, StackedColumn3D, PercentsStackedColumn3D, Column3D, ClusteredCylinder, StackedCylinder, PercentsStackedCylinder, Cylinder3D, ClusteredCone, StackedCone, PercentsStackedCone, Cone3D, ClusteredPyramid, StackedPyramid, PercentsStackedPyramid, Pyramid3D, Line, StackedLine, PercentsStackedLine, LineWithMarkers, StackedLineWithMarkers, PercentsStackedLineWithMarkers, Line3D, Pie, Pie3D, PieOfPie, ExplodedPie, ExplodedPie3D, BarOfPie, PercentsStackedBar, ClusteredBar3D, ClusteredBar, StackedBar, StackedBar3D, PercentsStackedBar3D, ClusteredHorizontalCylinder, StackedHorizontalCylinder, PercentsStackedHorizontalCylinder, ClusteredHorizontalCone, StackedHorizontalCone, PercentsStackedHorizontalCone, ClusteredHorizontalPyramid, StackedHorizontalPyramid, PercentsStackedHorizontalPyramid, Area, StackedArea, PercentsStackedArea, Area3D, StackedArea3D, PercentsStackedArea3D, ScatterWithMarkers, ScatterWithSmoothLinesAndMarkers, ScatterWithSmoothLines, ScatterWithStraightLinesAndMarkers, ScatterWithStraightLines, HighLowClose, OpenHighLowClose, VolumeHighLowClose, VolumeOpenHighLowClose, Surface3D, WireframeSurface3D, Contour, WireframeContour, Doughnut, ExplodedDoughnut, Bubble, BubbleWith3D, Radar, RadarWithMarkers, FilledRadar, SeriesOfMixedTypes, Treemap, Sunburst, Histogram, ParetoLine, BoxAndWhisker, Waterfall, Funnel, Map } enum DataPointTypeEnum { OneValue, Scatter, Bubble } } /** * Common properties for Bubble and Scatter series. */ export declare class XYSeries extends Series { constructor(); /** * The number format for the series y values. */ numberFormatOfYValues?: string; /** * The number format for the series x values. */ numberFormatOfXValues?: string; /** * Data source type for X Values. */ dataSourceForXValues?: DataSource; /** * Data source type for Y Values. */ dataSourceForYValues?: DataSource; } export declare namespace XYSeries { } /** * A bubble series. */ export declare class BubbleSeries extends XYSeries { constructor(); /** * Gets or sets the values. */ dataPoints?: Array; /** * The number format for the series bubble sizes. */ numberFormatOfBubbleSizes?: string; /** * Data source type for Bubble size values. */ dataSourceForBubbleSizeValues?: DataSource; } export declare namespace BubbleSeries { } /** * Camera */ export declare class Camera { /** * Camera type */ cameraType?: Camera.CameraTypeEnum; /** * Camera FOV */ fieldOfViewAngle?: number; /** * Camera zoom */ zoom?: number; /** * XRotation */ xRotation?: number; /** * YRotation */ yRotation?: number; /** * ZRotation */ zRotation?: number; } export declare namespace Camera { enum CameraTypeEnum { IsometricBottomDown, IsometricBottomUp, IsometricLeftDown, IsometricLeftUp, IsometricOffAxis1Left, IsometricOffAxis1Right, IsometricOffAxis1Top, IsometricOffAxis2Left, IsometricOffAxis2Right, IsometricOffAxis2Top, IsometricOffAxis3Bottom, IsometricOffAxis3Left, IsometricOffAxis3Right, IsometricOffAxis4Bottom, IsometricOffAxis4Left, IsometricOffAxis4Right, IsometricRightDown, IsometricRightUp, IsometricTopDown, IsometricTopUp, LegacyObliqueBottom, LegacyObliqueBottomLeft, LegacyObliqueBottomRight, LegacyObliqueFront, LegacyObliqueLeft, LegacyObliqueRight, LegacyObliqueTop, LegacyObliqueTopLeft, LegacyObliqueTopRight, LegacyPerspectiveBottom, LegacyPerspectiveBottomLeft, LegacyPerspectiveBottomRight, LegacyPerspectiveFront, LegacyPerspectiveLeft, LegacyPerspectiveRight, LegacyPerspectiveTop, LegacyPerspectiveTopLeft, LegacyPerspectiveTopRight, ObliqueBottom, ObliqueBottomLeft, ObliqueBottomRight, ObliqueLeft, ObliqueRight, ObliqueTop, ObliqueTopLeft, ObliqueTopRight, OrthographicFront, PerspectiveAbove, PerspectiveAboveLeftFacing, PerspectiveAboveRightFacing, PerspectiveBelow, PerspectiveContrastingLeftFacing, PerspectiveContrastingRightFacing, PerspectiveFront, PerspectiveHeroicExtremeLeftFacing, PerspectiveHeroicExtremeRightFacing, PerspectiveHeroicLeftFacing, PerspectiveHeroicRightFacing, PerspectiveLeft, PerspectiveRelaxed, PerspectiveRelaxedModerately, PerspectiveRight, NotDefined } } /** * Represents list of Links to Paragraphs resources */ export declare class CaptionTrack extends ResourceBase { constructor(); /** * Caption ID. */ captionId: string; /** * Label. */ label?: string; /** * Caption track data as string. */ dataAsString?: string; } /** * Represents list of Links to Paragraphs resources */ export declare class CaptionTracks extends ResourceBase { constructor(); /** * List of caption tracks. */ items?: Array; } /** * Represents chart resource */ export declare class Chart extends ShapeBase { constructor(); /** * Gets or sets the type of the chart. */ chartType: Chart.ChartTypeEnum; /** * True if data labels over the maximum of the chart shall be shown. */ showDataLabelsOverMaximum?: boolean; /** * Gets or sets the series of chart data values. */ series?: Array; /** * Gets or sets the categories for chart data */ categories?: Array; /** * Data source type for categories. */ dataSourceForCategories?: DataSource; /** * True if the chart has a title. */ hasTitle?: boolean; /** * Gets or sets the title. */ title?: ChartTitle; /** * Gets or sets the back wall. */ backWall?: ChartWall; /** * Gets or sets the side wall. */ sideWall?: ChartWall; /** * Gets or sets the floor. */ floor?: ChartWall; /** * Gets or sets the legend. */ legend?: Legend; /** * Gets or sets the axes. */ axes?: Axes; /** * Gets or sets the plot area. */ plotArea?: PlotArea; /** * Specifies the chart area shall have rounded corners. */ hasRoundedCorners?: boolean; /** * Gets groups of series. */ seriesGroups?: Array; } export declare namespace Chart { enum ChartTypeEnum { ClusteredColumn, StackedColumn, PercentsStackedColumn, ClusteredColumn3D, StackedColumn3D, PercentsStackedColumn3D, Column3D, ClusteredCylinder, StackedCylinder, PercentsStackedCylinder, Cylinder3D, ClusteredCone, StackedCone, PercentsStackedCone, Cone3D, ClusteredPyramid, StackedPyramid, PercentsStackedPyramid, Pyramid3D, Line, StackedLine, PercentsStackedLine, LineWithMarkers, StackedLineWithMarkers, PercentsStackedLineWithMarkers, Line3D, Pie, Pie3D, PieOfPie, ExplodedPie, ExplodedPie3D, BarOfPie, PercentsStackedBar, ClusteredBar3D, ClusteredBar, StackedBar, StackedBar3D, PercentsStackedBar3D, ClusteredHorizontalCylinder, StackedHorizontalCylinder, PercentsStackedHorizontalCylinder, ClusteredHorizontalCone, StackedHorizontalCone, PercentsStackedHorizontalCone, ClusteredHorizontalPyramid, StackedHorizontalPyramid, PercentsStackedHorizontalPyramid, Area, StackedArea, PercentsStackedArea, Area3D, StackedArea3D, PercentsStackedArea3D, ScatterWithMarkers, ScatterWithSmoothLinesAndMarkers, ScatterWithSmoothLines, ScatterWithStraightLinesAndMarkers, ScatterWithStraightLines, HighLowClose, OpenHighLowClose, VolumeHighLowClose, VolumeOpenHighLowClose, Surface3D, WireframeSurface3D, Contour, WireframeContour, Doughnut, ExplodedDoughnut, Bubble, BubbleWith3D, Radar, RadarWithMarkers, FilledRadar, SeriesOfMixedTypes, Treemap, Sunburst, Histogram, ParetoLine, BoxAndWhisker, Waterfall, Funnel, Map } } /** * Represents chart category resource */ export declare class ChartCategory { /** * Gets or sets the parent categories. Used with Sunburst & treemap categories; ignored for other chart types. */ parentCategories?: Array; /** * Gets or sets the grouping level for the category. Used with Sunburst & treemap categories; ignored for other chart types. */ level?: number; /** * Category value */ value?: string; /** * Get or sets the fill format. */ fillFormat?: FillFormat; /** * Get or sets the effect format. */ effectFormat?: EffectFormat; /** * Get or sets the line format. */ lineFormat?: LineFormat; /** * Gets or sets the data points for chart data */ dataPoints?: Array; } /** * Represents the lines format of chart elements. */ export declare class ChartLinesFormat { /** * Get or sets the effect format. */ effectFormat?: EffectFormat; /** * Get or sets the line format. */ lineFormat?: LineFormat; } /** * Chart series group. Defines common properties for a group of series. */ export declare class ChartSeriesGroup { /** * Returns a type of this series group. */ type?: ChartSeriesGroup.TypeEnum; /** * Specifies the space between bar or column clusters, as a percentage of the bar or column width. */ gapWidth?: number; /** * Returns or sets the distance, as a percentage of the marker width, between the data series in a 3D chart. */ gapDepth?: number; /** * Gets or sets the angle of the first pie or doughnut chart slice, in degrees (clockwise from up, from 0 to 360 degrees). */ firstSliceAngle?: number; /** * Specifies that each data marker in the series has a different color. */ isColorVaried?: boolean; /** * True if chart has series lines. Applied to stacked bar and OfPie charts. */ hasSeriesLines?: boolean; /** * Specifies how much bars and columns shall overlap on 2-D charts (from -100 to 100). */ overlap?: number; /** * Specifies the size of the second pie or bar of a pie-of-pie chart or a bar-of-pie chart, as a percentage of the size of the first pie (can be between 5 and 200 percents). */ secondPieSize?: number; /** * Specifies a value that shall be used to determine which data points are in the second pie or bar on a pie-of-pie or bar-of-pie chart. Is used together with PieSplitBy property. */ pieSplitPosition?: number; /** * Specifies how to determine which data points are in the second pie or bar on a pie-of-pie or bar-of-pie chart. */ pieSplitBy?: ChartSeriesGroup.PieSplitByEnum; /** * Specifies the size of the hole in a doughnut chart (can be between 10 and 90 percents of the size of the plot area.). */ doughnutHoleSize?: number; /** * Specifies the scale factor for the bubble chart (can be between 0 and 300 percents of the default size). Read/write Int32. */ bubbleSizeScale?: number; /** * Specifies HiLowLines format. HiLowLines applied with HiLowClose, OpenHiLowClose, VolumeHiLowClose and VolumeOpenHiLowClose chart types. */ hiLowLinesFormat?: ChartLinesFormat; /** * Specifies how the bubble size values are represented on the bubble chart. Read/write BubbleSizeRepresentationType. */ bubbleSizeRepresentation?: ChartSeriesGroup.BubbleSizeRepresentationEnum; } export declare namespace ChartSeriesGroup { enum TypeEnum { BarOfPieChart, PieOfPieChart, DoughnutChart, PieChart, AreaChartArea, AreaChartPercentsStackedArea, AreaChartStackedArea, BarChartHorizClustered, BarChartHorizStacked, BarChartHorizPercentsStacked, BarChartVertClustered, BarChartVertStacked, BarChartVertPercentsStacked, LineChartLine, LineChartStackedLine, LineChartPercentsStackedLine, RadarChart, FilledRadarChart, StockHighLowClose, StockOpenHighLowClose, StockVolumeHighLowClose, StockVolumeOpenHighLowClose, ScatterStraightMarker, ScatterSmoothMarker, AreaChartArea3D, AreaChartStackedArea3D, AreaChartPercentsStackedArea3D, Line3DChart, Pie3DChart, Bar3DChartVert, Bar3DChartVertClustered, Bar3DChartVertPercentsStackedColumn3D, Bar3DChartVertPercentsStackedCone, Bar3DChartVertPercentsStackedCylinder, Bar3DChartVertPercentsStackedPyramid, Bar3DChartVertStackedColumn3D, Bar3DChartVertStackedCone, Bar3DChartVertStackedCylinder, Bar3DChartVertStackedPyramid, Bar3DChartHorizClustered, Bar3DChartHorizStackedBar3D, Bar3DChartHorizStackedCone, Bar3DChartHorizStackedCylinder, Bar3DChartHorizStackedPyramid, Bar3DChartHorizPercentsStackedBar3D, Bar3DChartHorizPercentsStackedCone, Bar3DChartHorizPercentsStackedCylinder, Bar3DChartHorizPercentsStackedPyramid, SurfaceChartContour, SurfaceChartWireframeContour, SurfaceChartSurface3D, SurfaceChartWireframeSurface3D, BubbleChart, HistogramChart, ParetoLineChart, BoxAndWhiskerChart, WaterfallChart, FunnelChart, TreemapChart, MapChart, SunburstChart } enum PieSplitByEnum { Default, Custom, ByPercentage, ByPos, ByValue } enum BubbleSizeRepresentationEnum { Area, Width } } /** * Represents chart title */ export declare class ChartTitle { /** * Get or sets the text. */ text?: string; /** * the X location */ x?: number; /** * the Y location */ y?: number; /** * Width */ width?: number; /** * Height */ height?: number; /** * true if other elements are allowed to overlay the legend */ overlay?: boolean; /** * Get or sets the fill format. */ fillFormat?: FillFormat; /** * Get or sets the effect format. */ effectFormat?: EffectFormat; /** * Get or sets the line format. */ lineFormat?: LineFormat; } /** * Represents a chart wall */ export declare class ChartWall { /** * Get or sets the fill format. */ fillFormat?: FillFormat; /** * Get or sets the effect format. */ effectFormat?: EffectFormat; /** * Get or sets the line format. */ lineFormat?: LineFormat; /** * Get or sets wall thickness as a percentage of the largest dimension of the plot volume. */ thickness?: number; /** * Get or sets mode of bar picture filling. */ pictureType?: ChartWall.PictureTypeEnum; } export declare namespace ChartWall { enum PictureTypeEnum { Stack, StackScale, Stretch, NotDefined } } /** * 3D chart wall type */ /** * 3D chart wall type */ export declare enum ChartWallType { 'Floor', 'SideWall', 'BackWall' } /** * Close path segment of the geometry path */ export declare class ClosePathSegment extends PathSegment { constructor(); } export declare namespace ClosePathSegment { } /** * Represents a Color Change effect. */ export declare class ColorChangeEffect extends ImageTransformEffect { constructor(); /** * Color which will be replaced. */ fromColor?: string; /** * Color which will replace. */ toColor?: string; } export declare namespace ColorChangeEffect { } /** * Represents a Color Replacement effect. */ export declare class ColorReplaceEffect extends ImageTransformEffect { constructor(); /** * Returns color format which will replace color of every pixel. */ color?: string; } export declare namespace ColorReplaceEffect { } /** * Slide's color scheme DTO */ export declare class ColorScheme extends ResourceBase { constructor(); /** * First accent color. */ accent1?: string; /** * Second accent color. */ accent2?: string; /** * Third accent color. */ accent3?: string; /** * Fourth accent color. */ accent4?: string; /** * Fifth accent color. */ accent5?: string; /** * Sixth accent color. */ accent6?: string; /** * First dark color. */ dark1?: string; /** * Second dark color. */ dark2?: string; /** * Visited hyperlink color. */ followedHyperlink?: string; /** * Hyperlink color/ */ hyperlink?: string; /** * First light color. */ light1?: string; /** * Second light color. */ light2?: string; } /** * Represents a comment author */ export declare class CommentAuthor { /** * Name */ name?: string; /** * Initials */ initials?: string; } /** * Represents comments collection of slide */ export declare class CommentAuthors extends ResourceBase { constructor(); /** * Slide comment list. */ list?: Array; } /** * Slide view properties. */ export declare class CommonSlideViewProperties { /** * The view scaling ratio (percentage). */ scale?: number; /** * True if the view content should automatically scale to best fit the current window size. */ variableScale?: boolean; /** * Drawing guides */ drawingGuides?: Array; } /** * Represents Connector resource. */ export declare class Connector extends GeometryShape { constructor(); /** * Start shape link. */ startShapeConnectedTo?: ResourceUri; /** * Start shape index. */ startShapeConnectedToIndex?: number; /** * End shape link. */ endShapeConnectedTo?: ResourceUri; /** * End shape index. */ endShapeConnectedToIndex?: number; } export declare namespace Connector { } /** * Cubic Bezier curve segment of the geometry path */ export declare class CubicBezierToPathSegment extends PathSegment { constructor(); /** * X coordinate of the first direction point */ x1: number; /** * Y coordinate of the first direction point */ y1: number; /** * X coordinate of the second direction point */ x2: number; /** * Y coordinate of the second direction point */ y2: number; /** * X coordinate of end point */ x3: number; /** * Y coordinate of end point */ y3: number; } export declare namespace CubicBezierToPathSegment { } /** * Custom dash pattern. */ export declare class CustomDashPattern { /** * Pattern items. */ items?: Array; } /** * Data source for chart values. */ export declare class DataSource { type?: DataSource.TypeEnum; } export declare namespace DataSource { enum TypeEnum { Workbook, Literals } } /** * Delimiter element */ export declare class DelimiterElement extends MathElement { constructor(); /** * Arguments */ arguments?: Array; /** * Beginning character */ beginningCharacter?: string; /** * Separator character */ separatorCharacter?: string; /** * Ending character */ endingCharacter?: string; /** * Grow to match operand height */ growToMatchOperandHeight?: boolean; /** * Delimiter shape */ delimiterShape?: DelimiterElement.DelimiterShapeEnum; } export declare namespace DelimiterElement { enum DelimiterShapeEnum { Centered, Match } } /** * Class for disc space information. */ export declare class DiscUsage { /** * Application used disc space. */ usedSize: number; /** * Total disc space. */ totalSize: number; } /** * Represents document DTO. */ export declare class Document extends ResourceBase { constructor(); /** * Link to Document properties. */ documentProperties?: ResourceUri; /** * Link to Document properties. */ viewProperties?: ResourceUri; /** * Link to slides collection. */ slides?: ResourceUri; /** * Link to images collection. */ images?: ResourceUri; /** * Link to layout slides collection. */ layoutSlides?: ResourceUri; /** * Link to master slides collection. */ masterSlides?: ResourceUri; } /** * Slides document properties. */ export declare class DocumentProperties extends ResourceBase { constructor(); /** * Document property list. */ list?: Array; } /** * Document property. */ export declare class DocumentProperty extends ResourceBase { constructor(); /** * Name. */ name?: string; /** * Value. */ value?: string; /** * True for builtin property. */ builtIn?: boolean; } /** * Represents document replace result DTO. */ export declare class DocumentReplaceResult extends Document { constructor(); /** * Gets or sets the number of matches */ matches: number; } /** * Drawing guide. */ export declare class DrawingGuide { /** * Last used view mode. */ orientation: DrawingGuide.OrientationEnum; /** * Horizontal bar state. */ position: number; } export declare namespace DrawingGuide { enum OrientationEnum { Horizontal, Vertical } } /** * Represents a Duotone effect. */ export declare class DuotoneEffect extends ImageTransformEffect { constructor(); /** * Returns target color format for dark pixels. */ color1?: string; /** * Returns target color format for light pixels. */ color2?: string; } export declare namespace DuotoneEffect { } /** * Represents comment of slide */ export declare class Effect { /** * Effect type. */ type?: Effect.TypeEnum; /** * Effect subtype. */ subtype?: Effect.SubtypeEnum; /** * Preset class type. */ presetClassType?: Effect.PresetClassTypeEnum; /** * Preset class type. */ animateTextType?: Effect.AnimateTextTypeEnum; /** * Shape index. */ shapeIndex: number; /** * Paragraph index. */ paragraphIndex?: number; /** * Effect trigger type. */ triggerType?: Effect.TriggerTypeEnum; /** * The percentage of duration accelerate behavior effect. */ accelerate?: number; /** * True to automatically play the animation in reverse after playing it in the forward direction. */ autoReverse?: boolean; /** * The percentage of duration decelerate behavior effect. */ decelerate?: number; /** * The duration of animation effect. */ duration?: number; /** * The number of times the effect should repeat. */ repeatCount?: number; /** * The number of times the effect should repeat. */ repeatDuration?: number; /** * The way for a effect to restart after complete. */ restart?: Effect.RestartEnum; /** * The percentage by which to speed up (or slow down) the timing. */ speed?: number; /** * Delay time after trigger. */ triggerDelayTime?: number; /** * Specifies if the effect will repeat until the end of slide. */ repeatUntilEndSlide?: boolean; /** * Specifies if the effect will repeat until the next click. */ repeatUntilNextClick?: boolean; /** * This attribute specifies if the animation effect stops the previous sound. */ stopPreviousSound?: boolean; /** * This attribute specifies if the effect will rewind when done playing. */ rewind?: boolean; /** * Defined an after animation color for effect. */ afterAnimationType?: Effect.AfterAnimationTypeEnum; /** * Defined an after animation color for effect. Applied when the AfterAnimationType property is set to Color. */ afterAnimationColor?: string; } export declare namespace Effect { enum TypeEnum { Appear, CurveUpDown, Ascend, FloatUp, Blast, Blinds, Blink, BoldFlash, BoldReveal, Boomerang, Bounce, Box, BrushOnColor, BrushOnUnderline, CenterRevolve, ChangeFillColor, ChangeFont, ChangeFontColor, ChangeFontSize, ChangeFontStyle, ChangeLineColor, Checkerboard, Circle, ColorBlend, ColorTypewriter, ColorWave, ComplementaryColor, ComplementaryColor2, Compress, ContrastingColor, Crawl, Credits, Custom, Darken, Desaturate, Descend, Floatdown, Diamond, Dissolve, EaseInOut, Expand, Fade, FadedSwivel, FadedZoom, FlashBulb, FlashOnce, Flicker, Flip, Float, Fly, Fold, Glide, GrowAndTurn, GrowShrink, GrowWithColor, Lighten, LightSpeed, MediaPause, MediaPlay, MediaStop, Path4PointStar, Path5PointStar, Path6PointStar, Path8PointStar, PathArcDown, PathArcLeft, PathArcRight, PathArcUp, PathBean, PathBounceLeft, PathBounceRight, PathBuzzsaw, PathCircle, PathCrescentMoon, PathCurvedSquare, PathCurvedX, PathCurvyLeft, PathCurvyRight, PathCurvyStar, PathDecayingWave, PathDiagonalDownRight, PathDiagonalUpRight, PathDiamond, PathDown, PathEqualTriangle, PathFigure8Four, PathFootball, PathFunnel, PathHeart, PathHeartbeat, PathHexagon, PathHorizontalFigure8, PathInvertedSquare, PathInvertedTriangle, PathLeft, PathLoopdeLoop, PathNeutron, PathOctagon, PathParallelogram, PathPeanut, PathPentagon, PathPlus, PathPointyStar, PathRight, PathRightTriangle, PathSCurve1, PathSCurve2, PathSineWave, PathSpiralLeft, PathSpiralRight, PathSpring, PathSquare, PathStairsDown, PathSwoosh, PathTeardrop, PathTrapezoid, PathTurnDown, PathTurnRight, PathTurnUp, PathTurnUpRight, PathUp, PathUser, PathVerticalFigure8, PathWave, PathZigzag, Peek, Pinwheel, Plus, RandomBars, RandomEffects, RiseUp, Shimmer, Sling, Spin, Spinner, Spiral, Split, Stretch, Strips, StyleEmphasis, Swish, Swivel, Teeter, Thread, Transparency, Unfold, VerticalGrow, Wave, Wedge, Wheel, Whip, Wipe, Magnify, Zoom, OLEObjectShow, OLEObjectEdit, OLEObjectOpen } enum SubtypeEnum { None, Across, Bottom, BottomLeft, BottomRight, Center, ObjectCenter, SlideCenter, Clockwise, CounterClockwise, GradualAndCycleClockwise, GradualAndCycleCounterClockwise, Down, DownLeft, DownRight, FontAllCaps, FontBold, FontItalic, FontShadow, FontStrikethrough, FontUnderline, Gradual, Horizontal, HorizontalIn, HorizontalOut, In, InBottom, InCenter, InSlightly, Instant, Left, OrdinalMask, Out, OutBottom, OutCenter, OutSlightly, Right, Slightly, Top, TopLeft, TopRight, Up, UpLeft, UpRight, Vertical, VerticalIn, VerticalOut, Wheel1, Wheel2, Wheel3, Wheel4, Wheel8 } enum PresetClassTypeEnum { Entrance, Exit, Emphasis, Path, MediaCall, OLEActionVerbs } enum AnimateTextTypeEnum { AllAtOnce, ByWord, ByLetter } enum TriggerTypeEnum { AfterPrevious, OnClick, WithPrevious } enum RestartEnum { Always, WhenNotActive, Never, NotDefined } enum AfterAnimationTypeEnum { DoNotDim, Color, HideAfterAnimation, HideOnNextMouseClick } } /** * Effect format */ export declare class EffectFormat { /** * blur effect */ blur?: BlurEffect; /** * glow effect */ glow?: GlowEffect; /** * inner shadow effect */ innerShadow?: InnerShadowEffect; /** * outer shadow effect */ outerShadow?: OuterShadowEffect; /** * preset shadow effect */ presetShadow?: PresetShadowEffect; /** * soft edge effect */ softEdge?: SoftEdgeEffect; /** * reflection effect */ reflection?: ReflectionEffect; /** * fill overlay effect */ fillOverlay?: FillOverlayEffect; } /** * Information about object existence. */ export declare class EntityExists { /** * True if the object exists. */ exists: boolean; } /** * The error details */ export declare class ErrorDetails { /** * The request id */ requestId?: string; /** * Date */ date: Date; } /** * Available export formats */ /** * Available export formats */ export declare enum ExportFormat { 'Pdf', 'Xps', 'Tiff', 'Pptx', 'Odp', 'Otp', 'Ppt', 'Pps', 'Ppsx', 'Pptm', 'Ppsm', 'Pot', 'Potx', 'Potm', 'Html', 'Html5', 'Swf', 'Svg', 'Jpeg', 'Png', 'Gif', 'Bmp', 'Fodp', 'Xaml', 'Mpeg4', 'Md', 'Xml', 'Emf' } /** * Represents export options for whole presentation. */ export declare class ExportOptions { /** * Default regular font for rendering the presentation. */ defaultRegularFont?: string; /** * True to delete delete all embedded binary objects. */ deleteEmbeddedBinaryObjects?: boolean; /** * Default regular font for rendering the presentation. */ gradientStyle?: ExportOptions.GradientStyleEnum; /** * Gets of sets list of font fallback rules. */ fontFallbackRules?: Array; /** * Gets of sets list of font substitution rules. */ fontSubstRules?: Array; /** * True to skip hyperlinks with javascript calls when saving the presentation. */ skipJavaScriptLinks?: boolean; format?: string; } export declare namespace ExportOptions { enum GradientStyleEnum { Default, PowerPointUI } } /** * File or folder information */ export declare class StorageFile { /** * File or folder name. */ name?: string; /** * True if it is a folder. */ isFolder: boolean; /** * File or folder last modified DateTime. */ modifiedDate?: Date; /** * File or folder size. */ size: number; /** * File or folder path. */ path?: string; } /** * File Version */ export declare class FileVersion extends StorageFile { constructor(); /** * File Version ID. */ versionId?: string; /** * Specifies whether the file is (true) or is not (false) the latest version of an file. */ isLatest: boolean; } /** * File versions FileVersion. */ export declare class FileVersions { /** * File versions FileVersion. */ value?: Array; } /** * Files list */ export declare class FilesList { /** * Files and folders contained by folder StorageFile. */ value?: Array; } /** * File upload result */ export declare class FilesUploadResult { /** * List of uploaded file names */ uploaded?: Array; /** * List of errors. */ errors?: Array; } /** * Base class for fill formats */ export declare class FillFormat { type?: FillFormat.TypeEnum; } export declare namespace FillFormat { enum TypeEnum { NoFill, Solid, Gradient, Pattern, Picture, NotDefined } } /** * Represents fill overlay effect */ export declare class FillOverlayEffect { /** * blend mode */ blend: FillOverlayEffect.BlendEnum; } export declare namespace FillOverlayEffect { enum BlendEnum { Darken, Lighten, Multiply, Overlay, Screen } } /** * Represents a Fill Overlay effect. A fill overlay may be used to specify an additional fill for an object and blend the two fills together. */ export declare class FillOverlayImageEffect extends ImageTransformEffect { constructor(); /** * FillBlendMode. */ blend: FillOverlayImageEffect.BlendEnum; /** * Fill format. */ fillFormat?: FillFormat; } export declare namespace FillOverlayImageEffect { enum BlendEnum { Darken, Lighten, Multiply, Overlay, Screen } } /** * Represents font info. */ export declare class FontData { /** * Font name */ fontName?: string; /** * Returns true if font is embedded. */ isEmbedded?: boolean; /** * Returns true for a custom font (contained in fontsFolder directory). */ isCustom?: boolean; } /** * Represents font fallback rule. */ export declare class FontFallbackRule { /** * First index of continuous unicode range. */ rangeStartIndex: number; /** * Last index of continuous unicode range. */ rangeEndIndex: number; /** * List of fallback font links. */ fallbackFontList?: Array; } /** * Represents font scheme */ export declare class FontScheme extends ResourceBase { constructor(); /** * Gets or sets fonts collection for a \"heading\" part of the slide. */ major?: FontSet; /** * Gets or sets the fonts collection for a \"body\" part of the slide. */ minor?: FontSet; /** * Gets or sets the name. */ name?: string; } /** * Font set. */ export declare class FontSet { /** * Complex script font. */ complexScript?: string; /** * East Asian font. */ eastAsian?: string; /** * Latin font. */ latin?: string; } /** * Represents font substitution rule. */ export declare class FontSubstRule { /** * Font to substitute. */ sourceFont?: string; /** * Substitution font. */ targetFont?: string; /** * Substitute when font is not found. Default: true. */ notFoundOnly?: boolean; } /** * List of fonts data */ export declare class FontsData { /** * Fonts data list. */ list?: Array; } /** * Represents Format Scheme for slide's theme */ export declare class FormatScheme extends ResourceBase { constructor(); /** * Background styles. */ backgroundStyles?: Array; /** * Effect styles. */ effectStyles?: Array; /** * Fill styles. */ fillStyles?: Array; /** * Line style. */ lineStyles?: Array; } /** * Specifies the fraction object, consisting of a numerator and denominator separated by a fraction bar. */ export declare class FractionElement extends MathElement { constructor(); /** * Fraction type */ fractionType?: FractionElement.FractionTypeEnum; /** * Numerator */ numerator?: MathElement; /** * Denominator */ denominator?: MathElement; } export declare namespace FractionElement { enum FractionTypeEnum { Bar, Skewed, Linear, NoBar } } /** * Specifies a function of an argument. */ export declare class FunctionElement extends MathElement { constructor(); /** * Function */ name?: MathElement; /** * Function Argument */ base?: MathElement; } export declare namespace FunctionElement { } /** * Represents GeometryPath of the shape */ export declare class GeometryPath { /** * Path fill mode */ fillMode?: GeometryPath.FillModeEnum; /** * Stroke */ stroke?: boolean; /** * List of PathSegmen objects */ pathData?: Array; } export declare namespace GeometryPath { enum FillModeEnum { None, Normal, Lighten, LightenLess, Darken, DarkenLess } } /** * Represents container for GeometryPath objects */ export declare class GeometryPaths { /** * List of GeometryPath objects */ paths?: Array; } /** * The class provides shared options for image formats. */ export declare class ImageExportOptionsBase extends ExportOptions { constructor(); /** * Gets or sets the height of slides in the output image format. */ height?: number; /** * Gets or sets the height of slides in the output the output image format. */ width?: number; } export declare namespace ImageExportOptionsBase { } /** * Provides options that control how a presentation is saved in Gif format. */ export declare class GifExportOptions extends ImageExportOptionsBase { constructor(); /** * Determines whether hidden slides will be exported. */ exportHiddenSlides?: boolean; /** * Gets or sets transition FPS [frames/sec] */ transitionFps?: number; /** * Gets or sets default delay time [ms]. */ defaultDelay?: number; } export declare namespace GifExportOptions { } /** * Represents glow effect */ export declare class GlowEffect { /** * radius */ radius: number; /** * color */ color?: string; } /** * Represents gradient fill format */ export declare class GradientFill extends FillFormat { constructor(); /** * Gradient style. */ direction?: GradientFill.DirectionEnum; /** * Gradient shape. */ shape?: GradientFill.ShapeEnum; /** * Gradient stops. */ stops?: Array; /** * Gradient angle. */ linearAngle?: number; /** * True if the gradient is scaled. */ isScaled?: boolean; /** * Gradient flipping mode. */ tileFlip?: GradientFill.TileFlipEnum; } export declare namespace GradientFill { enum DirectionEnum { FromCorner1, FromCorner2, FromCorner3, FromCorner4, FromCenter, NotDefined } enum ShapeEnum { Linear, Rectangle, Radial, Path, NotDefined } enum TileFlipEnum { NoFlip, FlipX, FlipY, FlipBoth, NotDefined } } /** * Gradient stop. */ export declare class GradientFillStop { /** * Color. */ color?: string; /** * Stop position (0..1). */ position: number; } /** * Represents AudioFrame resource. */ export declare class GraphicalObject extends ShapeBase { constructor(); } export declare namespace GraphicalObject { } /** * Represents an Gray Scale effect. */ export declare class GrayScaleEffect extends ImageTransformEffect { constructor(); } export declare namespace GrayScaleEffect { } /** * Represents GroupShape resource. */ export declare class GroupShape extends ShapeBase { constructor(); /** * Gets or sets the link to shapes. */ shapes?: ResourceUri; } export declare namespace GroupShape { } /** * Specifies a grouping symbol above or below an expression, usually to highlight the relationship between elements */ export declare class GroupingCharacterElement extends MathElement { constructor(); /** * Base */ base?: MathElement; /** * Grouping character */ character?: string; /** * Position of grouping character. */ position?: GroupingCharacterElement.PositionEnum; /** * Vertical justification of group character. */ verticalJustification?: GroupingCharacterElement.VerticalJustificationEnum; } export declare namespace GroupingCharacterElement { enum PositionEnum { NotDefined, Top, Bottom } enum VerticalJustificationEnum { NotDefined, Top, Bottom } } /** * Slides layouting options. */ export declare class SlidesLayoutOptions { layoutType?: SlidesLayoutOptions.LayoutTypeEnum; } export declare namespace SlidesLayoutOptions { enum LayoutTypeEnum { NotesComments, Handout } } /** * Handout layouting options */ export declare class HandoutLayoutingOptions extends SlidesLayoutOptions { constructor(); /** * Specified how many pages and in what sequence will be placed on the page. */ handout?: HandoutLayoutingOptions.HandoutEnum; /** * True to print the displayed slide numbers. */ printSlideNumbers?: boolean; /** * True to display comments on slide. */ printComments?: boolean; /** * True to draw frames around the displayed slides. */ printFrameSlide?: boolean; } export declare namespace HandoutLayoutingOptions { enum HandoutEnum { Handouts1, Handouts2, Handouts3, Handouts4Horizontal, Handouts4Vertical, Handouts6Horizontal, Handouts6Vertical, Handouts9Horizontal, Handouts9Vertical } } /** * Represents header/footer info of slide */ export declare class HeaderFooter extends ResourceBase { constructor(); /** * True if date is displayed in the footer */ isDateTimeVisible?: boolean; /** * Text to be displayed as date in the footer */ dateTimeText?: string; /** * True if footer is displayed */ isFooterVisible?: boolean; /** * Text to be displayed in the footer */ footerText?: string; /** * True if slide number is displayed in the footer */ isSlideNumberVisible?: boolean; } /** * Represents a Hue/Saturation/Luminance effect. */ export declare class HslEffect extends ImageTransformEffect { constructor(); /** * Hue */ hue: number; /** * Saturation */ saturation: number; /** * Luminance */ luminance: number; } export declare namespace HslEffect { } /** * Provides options that control how a presentation is saved in Html5 format. */ export declare class Html5ExportOptions extends ExportOptions { constructor(); /** * Gets or sets transitions animation option. */ animateTransitions?: boolean; /** * Gets or sets shapes animation option. */ animateShapes?: boolean; /** * Gets or sets embed images option. */ embedImages?: boolean; /** * Slides layouting options */ slidesLayoutOptions?: SlidesLayoutOptions; /** * Path to custom templates */ templatesPath?: string; /** * true to disable ligatures in the rendered output. */ disableFontLigatures?: boolean; } export declare namespace Html5ExportOptions { } /** * Provides options that control how a presentation is saved in Html format. */ export declare class HtmlExportOptions extends ExportOptions { constructor(); /** * Get or sets flag for save presentation as zip file */ saveAsZip?: boolean; /** * Get or set name of subdirectory in zip-file for store external files */ subDirectoryName?: string; /** * Specifies whether the generated document should include hidden slides or not. Default is false. */ showHiddenSlides?: boolean; /** * True to make layout responsive by excluding width and height attributes from svg container. */ svgResponsiveLayout?: boolean; /** * Returns or sets a value determining the quality of the JPEG images inside PDF document. */ jpegQuality?: number; /** * Represents the pictures compression level */ picturesCompression?: HtmlExportOptions.PicturesCompressionEnum; /** * A boolean flag indicates if the cropped parts remain as part of the document. If true the cropped parts will removed, if false they will be serialized in the document (which can possible lead to a larger file) */ deletePicturesCroppedAreas?: boolean; /** * Slides layouting options */ slidesLayoutOptions?: SlidesLayoutOptions; /** * true to disable ligatures in the rendered output. */ disableFontLigatures?: boolean; } export declare namespace HtmlExportOptions { enum PicturesCompressionEnum { Dpi330, Dpi220, Dpi150, Dpi96, Dpi72, DocumentResolution } } /** * Hyperlink */ export declare class Hyperlink { /** * If true Hypelink is not applied. */ isDisabled?: boolean; /** * Type of HyperLink action */ actionType: Hyperlink.ActionTypeEnum; /** * Specifies the external URL */ externalUrl?: string; /** * Index of the target slide */ targetSlideIndex?: number; /** * Target frame */ targetFrame?: string; /** * Hyperlink tooltip */ tooltip?: string; /** * Makes hyperlink viewed when it is invoked. */ history?: boolean; /** * Determines whether the hyperlink should be highlighted on click. */ highlightClick?: boolean; /** * Determines whether the sound should be stopped on hyperlink click */ stopSoundOnClick?: boolean; /** * Represents the source of hyperlink color */ colorSource?: Hyperlink.ColorSourceEnum; /** * Audio data encoded in base64. Represents the playing sound of the hyperlink. */ soundBase64?: string; } export declare namespace Hyperlink { enum ActionTypeEnum { NoAction, Hyperlink, JumpFirstSlide, JumpPreviousSlide, JumpNextSlide, JumpLastSlide, JumpEndShow, JumpLastViewedSlide, JumpSpecificSlide, StartCustomSlideShow, OpenFile, OpenPresentation, StartStopMedia, StartMacro, StartProgram, Unknown } enum ColorSourceEnum { Styles, PortionFormat } } /** * Represents export options for whole presentation. */ export declare class IShapeExportOptions { } /** * Represents image DTO. */ export declare class Image extends ResourceBase { constructor(); /** * Get or sets the width of an image. */ width: number; /** * Get or sets the height of an image. */ height: number; /** * Get or sets the content type of an image. */ contentType?: string; } /** * Represents a format for image export. */ /** * Represents a format for image export. */ export declare enum ImageExportFormat { 'Jpeg', 'Png', 'Gif', 'Bmp', 'Tiff' } /** * Provides options that control how a presentation is saved in an image format. */ export declare class ImageExportOptions extends ImageExportOptionsBase { constructor(); /** * Show hidden slides. If true, hidden are exported. */ showHiddenSlides?: boolean; /** * Slides layouting options */ slidesLayoutOptions?: SlidesLayoutOptions; } export declare namespace ImageExportOptions { } /** * List of images. */ export declare class Images extends ResourceBase { constructor(); /** * Image list. */ list?: Array; } /** * Represents inner shadow effect */ export declare class InnerShadowEffect { /** * direction */ direction: number; /** * distance */ distance: number; /** * blur radius */ blurRadius: number; /** * shadow color */ shadowColor?: string; } /** * Represents input document for pipeline. */ export declare class Input { /** * Get or sets template document. If property is null new empty presentation will be created. */ template?: InputFile; /** * Get or sets html data for generate new presentation. */ htmlData?: InputFile; /** * Get or sets data for template engine. */ templateData?: InputFile; } /** * Represents comments collection of slide */ export declare class InteractiveSequence { /** * Effect list. */ effects?: Array; /** * Index of the shape that triggers the sequence. */ triggerShapeIndex: number; } /** * Layout slide. */ export declare class LayoutSlide extends ResourceBase { constructor(); /** * Name. */ name?: string; /** * Layout slide type. */ type: LayoutSlide.TypeEnum; /** * Master slide link. */ masterSlide?: ResourceUri; /** * List of depending slides. */ dependingSlides?: Array; } export declare namespace LayoutSlide { enum TypeEnum { Title, Text, TwoColumnText, Table, TextAndChart, ChartAndText, Diagram, Chart, TextAndClipArt, ClipArtAndText, TitleOnly, Blank, TextAndObject, ObjectAndText, Object, TitleAndObject, TextAndMedia, MediaAndText, ObjectOverText, TextOverObject, TextAndTwoObjects, TwoObjectsAndText, TwoObjectsOverText, FourObjects, VerticalText, ClipArtAndVerticalText, VerticalTitleAndText, VerticalTitleAndTextOverChart, TwoObjects, ObjectAndTwoObject, TwoObjectsAndObject, SectionHeader, TwoTextAndTwoObjects, TitleObjectAndCaption, PictureAndCaption, Custom } } /** * Layout slide list. */ export declare class LayoutSlides extends ResourceBase { constructor(); /** * List of layout slide links. */ slideList?: Array; } /** * Specifies the Sub-Superscript object */ export declare class LeftSubSuperscriptElement extends MathElement { constructor(); /** * Base argument */ base?: MathElement; /** * Subscript */ subscript?: MathElement; /** * Superscript */ superscript?: MathElement; } export declare namespace LeftSubSuperscriptElement { } /** * Represents a chart legend */ export declare class Legend { /** * position */ position?: Legend.PositionEnum; /** * the X location */ x?: number; /** * the Y location */ y?: number; /** * Width */ width?: number; /** * Height */ height?: number; /** * true if other elements are allowed to overlay the legend */ overlay?: boolean; /** * Get or sets the fill format. */ fillFormat?: FillFormat; /** * Get or sets the effect format. */ effectFormat?: EffectFormat; /** * Get or sets the line format. */ lineFormat?: LineFormat; /** * Get or sets value determines the visibility of legend */ hasLegend?: boolean; } export declare namespace Legend { enum PositionEnum { Bottom, Left, Right, Top, TopRight } } /** * Light rig */ export declare class LightRig { /** * Light direction */ direction?: LightRig.DirectionEnum; /** * Light type */ lightType?: LightRig.LightTypeEnum; /** * XRotation */ xRotation?: number; /** * YRotation */ yRotation?: number; /** * ZRotation */ zRotation?: number; } export declare namespace LightRig { enum DirectionEnum { TopLeft, Top, TopRight, Right, BottomRight, Bottom, BottomLeft, Left, NotDefined } enum LightTypeEnum { Balanced, BrightRoom, Chilly, Contrasting, Flat, Flood, Freezing, Glow, Harsh, LegacyFlat1, LegacyFlat2, LegacyFlat3, LegacyFlat4, LegacyHarsh1, LegacyHarsh2, LegacyHarsh3, LegacyHarsh4, LegacyNormal1, LegacyNormal2, LegacyNormal3, LegacyNormal4, Morning, Soft, Sunrise, Sunset, ThreePt, TwoPt, NotDefined } } /** * Specifies the Limit object */ export declare class LimitElement extends MathElement { constructor(); /** * Base */ base?: MathElement; /** * Limit */ limit?: MathElement; /** * Specifies upper or lower limit */ upperLimit?: boolean; } export declare namespace LimitElement { } /** * Line format. */ export declare class LineFormat { /** * Alignment. */ alignment?: LineFormat.AlignmentEnum; /** * Cap style. */ capStyle?: LineFormat.CapStyleEnum; /** * Dash style. */ dashStyle?: LineFormat.DashStyleEnum; /** * Join style. */ joinStyle?: LineFormat.JoinStyleEnum; /** * Style. */ style?: LineFormat.StyleEnum; /** * Sketch type. */ sketchType?: LineFormat.SketchTypeEnum; /** * Begin arrowhead. */ beginArrowHead?: ArrowHeadProperties; /** * End arrowhead. */ endArrowHead?: ArrowHeadProperties; /** * Custom dash pattern. */ customDashPattern?: CustomDashPattern; /** * Fill format. */ fillFormat?: FillFormat; /** * Miter limit. */ miterLimit?: number; /** * Width. */ width?: number; } export declare namespace LineFormat { enum AlignmentEnum { Center, Inset, NotDefined } enum CapStyleEnum { Round, Square, Flat, NotDefined } enum DashStyleEnum { Solid, Dot, Dash, LargeDash, DashDot, LargeDashDot, LargeDashDotDot, SystemDash, SystemDot, SystemDashDot, SystemDashDotDot, Custom, NotDefined } enum JoinStyleEnum { Round, Bevel, Miter, NotDefined } enum StyleEnum { Single, ThinThin, ThinThick, ThickThin, ThickBetweenThin, NotDefined } enum SketchTypeEnum { None, Curved, Freehand, Scribble, NotDefined } } /** * Line segment of the geometry path */ export declare class LineToPathSegment extends PathSegment { constructor(); /** * X coordinate of the end point of the line */ x: number; /** * Y coordinate of the end point of the line */ y: number; } export declare namespace LineToPathSegment { } /** * Represents string or double literals data source. */ export declare class Literals extends DataSource { constructor(); } export declare namespace Literals { } /** * Represents a Luminance effect. */ export declare class LuminanceEffect extends ImageTransformEffect { constructor(); /** * Brightness */ brightness: number; /** * Contrast */ contrast: number; } export declare namespace LuminanceEffect { } /** * Provides options that control how a presentation is saved in Html5 format. */ export declare class MarkdownExportOptions extends ExportOptions { constructor(); /** * Specifies markdown specification to convert presentation. Default is TextOnly. */ exportType?: MarkdownExportOptions.ExportTypeEnum; /** * Specifies markdown specification to convert presentation. Default is MultiMarkdown. */ flavor?: MarkdownExportOptions.FlavorEnum; /** * Specifies whether the generated document should have new lines of \\\\r(Macintosh), \\\\n(Unix) or \\\\r\\\\n(Windows). Default is Unix. */ newLineType?: MarkdownExportOptions.NewLineTypeEnum; /** * Specifies folder name to save images. Default is Images. */ imagesSaveFolderName?: string; /** * Specifies whether the generated document should include slide number. Default is false. */ showSlideNumber?: boolean; /** * Specifies whether the generated document should include comments. Default is false. */ showComments?: boolean; /** * Specifies whether the generated document should include hidden slides. Default is false. */ showHiddenSlides?: boolean; /** * true to remove empty or whitespace-only lines from the final Markdown output. Default is false. */ removeEmptyLines?: boolean; /** * Specifies how repeated space characters are preserved to maintain visual alignment. */ handleRepeatedSpaces?: MarkdownExportOptions.HandleRepeatedSpacesEnum; /** * The format of slide number headers. */ slideNumberFormat?: string; } export declare namespace MarkdownExportOptions { enum ExportTypeEnum { Sequential, TextOnly, Visual } enum FlavorEnum { Github, Gruber, MultiMarkdown, CommonMark, MarkdownExtra, Pandoc, Kramdown, Markua, Maruku, Markdown2, Remarkable, Showdown, Ghost, GitLab, Haroopad, IaWriter, Redcarpet, ScholarlyMarkdown, Taiga, Trello, S9ETextFormatter, XWiki, StackOverflow, Default } enum NewLineTypeEnum { Windows, Unix, Mac } enum HandleRepeatedSpacesEnum { None, AlternateSpacesToNbsp, MultipleSpacesToNbsp } } /** * Master slide. */ export declare class MasterSlide extends ResourceBase { constructor(); /** * Name. */ name?: string; /** * List of layout slide links. */ layoutSlides?: Array; /** * List of depending slide links. */ dependingSlides?: Array; } /** * Master slide list. */ export declare class MasterSlides extends ResourceBase { constructor(); /** * List of slide links. */ slideList?: Array; } /** * Mathematical paragraph that is a container for mathematical blocks */ /** * Mathematical paragraph that is a container for mathematical blocks */ export declare enum MathFormat { 'MathML', 'LaTeX' } /** * Mathematical paragraph that is a container for mathematical blocks */ export declare class MathParagraph { /** * List of math blocks */ mathBlockList?: Array; /** * Justification of the math paragraph */ justification?: MathParagraph.JustificationEnum; } export declare namespace MathParagraph { enum JustificationEnum { LeftJustified, RightJustified, Centered, CenteredAsGroup } } /** * Specifies the Matrix object, */ export declare class MatrixElement extends MathElement { constructor(); /** * Hide the placeholders for empty matrix elements */ hidePlaceholders?: boolean; /** * Specifies the vertical justification respect to surrounding text. */ baseJustification?: MatrixElement.BaseJustificationEnum; /** * Minimum column width in twips (1/20th of a point) */ minColumnWidth?: number; /** * The type of horizontal spacing between columns of a matrix. */ columnGapRule?: MatrixElement.ColumnGapRuleEnum; /** * The value of horizontal spacing between columns of a matrix */ columnGap?: number; /** * The type of vertical spacing between rows of a matrix */ rowGapRule?: MatrixElement.RowGapRuleEnum; /** * The value of vertical spacing between rows of a matrix; */ rowGap?: number; /** * Matrix items */ items?: Array>; } export declare namespace MatrixElement { enum BaseJustificationEnum { NotDefined, Top, Center, Bottom } enum ColumnGapRuleEnum { SingleSpacingGap, OneAndHalfSpacingGap, DoubleSpacingGap, Exactly, Multiple } enum RowGapRuleEnum { SingleSpacingGap, OneAndHalfSpacingGap, DoubleSpacingGap, Exactly, Multiple } } /** * Merge presentations task. */ export declare class Merge extends Task { constructor(); /** * Information about documents and slides being merging sources. */ presentations?: Array; } export declare namespace Merge { } /** * Merging source. */ export declare class MergingSource { /** * Source file. */ input?: InputFile; /** * Indices of slides to be merged. */ slides?: Array; } /** * Error */ export declare class ModelError { /** * Code */ code?: string; /** * Message */ message?: string; /** * Description */ description?: string; /** * Inner Error */ innerError?: ErrorDetails; } /** * MoveTo segment of the geometry path */ export declare class MoveToPathSegment extends PathSegment { constructor(); /** * X coordinate of the point. */ x: number; /** * Y coordinate of the point. */ y: number; } export declare namespace MoveToPathSegment { } /** * Specifies an N-ary mathematical object, such as Summation and Integral. */ export declare class NaryOperatorElement extends MathElement { constructor(); /** * Base argument */ base?: MathElement; /** * Subscript argument */ subscript?: MathElement; /** * Superscript argument */ superscript?: MathElement; /** * Nary Operator Character */ operator?: string; /** * The location of limits (subscript and superscript) */ limitLocation?: NaryOperatorElement.LimitLocationEnum; /** * Operator Character grows vertically to match its operand height */ growToMatchOperandHeight?: boolean; /** * Hide Subscript */ hideSubscript?: boolean; /** * Hide Superscript */ hideSuperscript?: boolean; } export declare namespace NaryOperatorElement { enum LimitLocationEnum { NotDefined, UnderOver, SubscriptSuperscript } } /** * Represents empty fill */ export declare class NoFill extends FillFormat { constructor(); } export declare namespace NoFill { } /** * The sizing of the slide region. */ export declare class NormalViewRestoredProperties { /** * True if the size of the side content region should compensate for the new size when resizing the window containing the view within the application. */ autoAdjust?: boolean; /** * The size of the slide region. */ dimensionSize?: number; } /** * Notes & comments layouting options. */ export declare class NotesCommentsLayoutingOptions extends SlidesLayoutOptions { constructor(); /** * Gets or sets the position of the notes on the page. */ notesPosition?: NotesCommentsLayoutingOptions.NotesPositionEnum; /** * Gets or sets the position of the comments on the page. */ commentsPosition?: NotesCommentsLayoutingOptions.CommentsPositionEnum; /** * Gets or sets the width of the comment output area in pixels (Applies only if comments are displayed on the right). */ commentsAreaWidth?: number; /** * Gets or sets the color of comments area (Applies only if comments are displayed on the right). */ commentsAreaColor?: string; /** * True if comments that have no author are displayed. (Applies only if comments are displayed). */ showCommentsByNoAuthor?: boolean; } export declare namespace NotesCommentsLayoutingOptions { enum NotesPositionEnum { None, BottomFull, BottomTruncated } enum CommentsPositionEnum { None, Bottom, Right } } /** * Represents notes slide DTO. */ export declare class NotesSlide extends ResourceBase { constructor(); /** * Get or sets text of notes slide. */ text?: string; /** * Get or sets the link to list notes slide shapes. */ shapes?: ResourceUri; } /** * Represents a format for notes slide export. */ /** * Represents a format for notes slide export. */ export declare enum NotesSlideExportFormat { 'Jpeg', 'Png', 'Gif', 'Bmp', 'Tiff', 'Html', 'Pdf', 'Xps', 'Pptx', 'Odp', 'Otp', 'Ppt', 'Pps', 'Ppsx', 'Pptm', 'Ppsm', 'Potx', 'Pot', 'Potm', 'Svg', 'Fodp', 'Xaml', 'Html5' } /** * Represents header/footer info of notes slide */ export declare class NotesSlideHeaderFooter extends ResourceBase { constructor(); /** * True if date is displayed in the footer */ isDateTimeVisible?: boolean; /** * Text to be displayed as date in the footer */ dateTimeText?: string; /** * True if footer is displayed */ isFooterVisible?: boolean; /** * Text to be displayed in the footer */ footerText?: string; /** * True if header is displayed */ isHeaderVisible?: boolean; /** * Text to be displayed in the header */ headerText?: string; /** * True if slide number is displayed in the footer */ isSlideNumberVisible?: boolean; } /** * Object exists */ export declare class ObjectExist { /** * Indicates that the file or folder exists. */ exists: boolean; /** * True if it is a folder, false if it is a file. */ isFolder: boolean; } /** * Represents OleObjectFrame resource. */ export declare class OleObjectFrame extends ShapeBase { constructor(); /** * True if an object is visible as icon. */ isObjectIcon?: boolean; /** * The title for OleObject icon. */ substitutePictureTitle?: string; /** * OleObject image fill properties. */ substitutePictureFormat?: PictureFill; /** * Returns or sets the name of an object. */ objectName?: string; /** * File data of embedded OLE object. */ embeddedFileBase64Data?: string; /** * File extension for the current embedded OLE object */ embeddedFileExtension?: string; /** * ProgID of an object. */ objectProgId?: string; /** * Full path to a linked file. */ linkPath?: string; /** * Determines if the linked embedded object is automatically updated when the presentation is opened or printed. Read/write Boolean. */ updateAutomatic?: boolean; } export declare namespace OleObjectFrame { } /** * One value chart data point. */ export declare class OneValueChartDataPoint extends DataPoint { constructor(); /** * Value. */ value?: number; /** * Spreadsheet formula in A1-style. */ valueFormula?: string; /** * SetAsTotal. Applied to Waterfall data points only. */ setAsTotal?: boolean; /** * True if the data point shall invert its colors if the value is negative. Applies to bar, column and bubble series. */ invertIfNegative?: boolean; } export declare namespace OneValueChartDataPoint { } /** * One value series. */ export declare class OneValueSeries extends Series { constructor(); /** * Gets or sets the values. */ dataPoints?: Array; /** * The number format for the series values. */ numberFormatOfValues?: string; /** * Data source type for values. */ dataSourceForValues?: DataSource; /** * True if inner points are shown. Applied to Waterfall series only. */ showConnectorLines?: boolean; /** * Quartile method. Applied to BoxAndWhisker series only. */ quartileMethod?: OneValueSeries.QuartileMethodEnum; /** * True if inner points are shown. Applied to BoxAndWhisker series only. */ showInnerPoints?: boolean; /** * True if mean line is shown. Applied to BoxAndWhisker series only. */ showMeanLine?: boolean; /** * True if mean markers are shown. Applied to BoxAndWhisker series only. */ showMeanMarkers?: boolean; /** * True if outlier points are shown. Applied to BoxAndWhisker series only. */ showOutlierPoints?: boolean; } export declare namespace OneValueSeries { enum QuartileMethodEnum { Exclusive, Inclusive } } export declare class Operation { id: string; method: Operation.MethodEnum; status: Operation.StatusEnum; progress?: OperationProgress; created?: Date; started?: Date; failed?: Date; canceled?: Date; finished?: Date; error?: OperationError; } export declare namespace Operation { enum MethodEnum { Convert, DownloadPresentation, ConvertAndSave, SavePresentation, Merge, MergeAndSave, Split, UploadAndSplit } enum StatusEnum { Created, Enqueued, Started, Failed, Canceled, Finished } } export declare class OperationError { code?: string; description?: string; httpStatusCode: number; message?: string; } /** * Operation progress. */ export declare class OperationProgress { /** * Description. */ description?: string; /** * Current Step Index. */ stepIndex: number; /** * Current Step Index. */ stepCount: number; } /** * Request for presentations merge with optional order of slides */ export declare class OrderedMergeRequest { /** * Gets or sets the presentation paths. */ presentations?: Array; } /** * Represents outer shadow effect */ export declare class OuterShadowEffect { /** * direction */ direction: number; /** * distance */ distance: number; /** * blur radius */ blurRadius: number; /** * shadow color */ shadowColor?: string; } /** * Represents output file destination in pipeline. */ export declare class OutputFile { type?: OutputFile.TypeEnum; } export declare namespace OutputFile { enum TypeEnum { Path, Response } } /** * Represents paragraph resource */ export declare class Paragraph extends ResourceBase { constructor(); /** * Left margin. */ marginLeft?: number; /** * Right margin. */ marginRight?: number; /** * Left spacing. */ spaceBefore?: number; /** * Right spacing. */ spaceAfter?: number; /** * Spacing between lines. */ spaceWithin?: number; /** * First line indent. */ indent?: number; /** * Text alignment. */ alignment?: Paragraph.AlignmentEnum; /** * Font alignment. */ fontAlignment?: Paragraph.FontAlignmentEnum; /** * Default tabulation size. */ defaultTabSize?: number; /** * Depth. */ depth?: number; /** * True if hanging punctuation is used with the paragraph. */ hangingPunctuation?: Paragraph.HangingPunctuationEnum; /** * True if East Asian line break is used with the paragraph. */ eastAsianLineBreak?: Paragraph.EastAsianLineBreakEnum; /** * True if Latin line break is used with the paragraph. */ latinLineBreak?: Paragraph.LatinLineBreakEnum; /** * True if right to left direction is used with the paragraph. */ rightToLeft?: Paragraph.RightToLeftEnum; /** * List of portion links. */ portionList?: Array; /** * Default portion format. */ defaultPortionFormat?: PortionFormat; /** * Bullet char. */ bulletChar?: string; /** * Bullet height. */ bulletHeight?: number; /** * Bullet type. */ bulletType?: Paragraph.BulletTypeEnum; /** * Starting number for a numbered bullet. */ numberedBulletStartWith?: number; /** * Numbered bullet style. */ numberedBulletStyle?: Paragraph.NumberedBulletStyleEnum; /** * Bullet fill format. */ bulletFillFormat?: FillFormat; } export declare namespace Paragraph { enum AlignmentEnum { Left, Center, Right, Justify, JustifyLow, Distributed, NotDefined } enum FontAlignmentEnum { Automatic, Top, Center, Bottom, Baseline, Default } enum HangingPunctuationEnum { False, True, NotDefined } enum EastAsianLineBreakEnum { False, True, NotDefined } enum LatinLineBreakEnum { False, True, NotDefined } enum RightToLeftEnum { False, True, NotDefined } enum BulletTypeEnum { None, Symbol, Numbered, Picture, NotDefined } enum NumberedBulletStyleEnum { BulletAlphaLCPeriod, BulletAlphaUCPeriod, BulletArabicParenRight, BulletArabicPeriod, BulletRomanLCParenBoth, BulletRomanLCParenRight, BulletRomanLCPeriod, BulletRomanUCPeriod, BulletAlphaLCParenBoth, BulletAlphaLCParenRight, BulletAlphaUCParenBoth, BulletAlphaUCParenRight, BulletArabicParenBoth, BulletArabicPlain, BulletRomanUCParenBoth, BulletRomanUCParenRight, BulletSimpChinPlain, BulletSimpChinPeriod, BulletCircleNumDBPlain, BulletCircleNumWDWhitePlain, BulletCircleNumWDBlackPlain, BulletTradChinPlain, BulletTradChinPeriod, BulletArabicAlphaDash, BulletArabicAbjadDash, BulletHebrewAlphaDash, BulletKanjiKoreanPlain, BulletKanjiKoreanPeriod, BulletArabicDBPlain, BulletArabicDBPeriod, BulletThaiAlphaPeriod, BulletThaiAlphaParenRight, BulletThaiAlphaParenBoth, BulletThaiNumPeriod, BulletThaiNumParenRight, BulletThaiNumParenBoth, BulletHindiAlphaPeriod, BulletHindiNumPeriod, BulletKanjiSimpChinDBPeriod, BulletHindiNumParenRight, BulletHindiAlpha1Period, NotDefined } } /** * Paragraph formatting properties. */ export declare class ParagraphFormat { /** * Depth. */ depth?: number; /** * Text alignment. */ alignment?: ParagraphFormat.AlignmentEnum; /** * Left margin. */ marginLeft?: number; /** * Right margin. */ marginRight?: number; /** * Left spacing. */ spaceBefore?: number; /** * Right spacing. */ spaceAfter?: number; /** * Spacing between lines. */ spaceWithin?: number; /** * Font alignment. */ fontAlignment?: ParagraphFormat.FontAlignmentEnum; /** * First line indent. */ indent?: number; /** * Determines whether the Right to Left writing is used in a paragraph. No inheritance applied. */ rightToLeft?: ParagraphFormat.RightToLeftEnum; /** * Determines whether the East Asian line break is used in a paragraph. No inheritance applied. */ eastAsianLineBreak?: ParagraphFormat.EastAsianLineBreakEnum; /** * Determines whether the Latin line break is used in a paragraph. No inheritance applied. */ latinLineBreak?: ParagraphFormat.LatinLineBreakEnum; /** * Determines whether the hanging punctuation is used in a paragraph. No inheritance applied. */ hangingPunctuation?: ParagraphFormat.HangingPunctuationEnum; /** * Returns or sets default tabulation size with no inheritance. */ defaultTabSize?: number; /** * Default portion format. */ defaultPortionFormat?: PortionFormat; /** * Bullet char. */ bulletChar?: string; /** * Bullet height. */ bulletHeight?: number; /** * Bullet type. */ bulletType?: ParagraphFormat.BulletTypeEnum; /** * Starting number for a numbered bullet. */ numberedBulletStartWith?: number; /** * Numbered bullet style. */ numberedBulletStyle?: ParagraphFormat.NumberedBulletStyleEnum; /** * Bullet fill format. */ bulletFillFormat?: FillFormat; } export declare namespace ParagraphFormat { enum AlignmentEnum { Left, Center, Right, Justify, JustifyLow, Distributed, NotDefined } enum FontAlignmentEnum { Automatic, Top, Center, Bottom, Baseline, Default } enum RightToLeftEnum { False, True, NotDefined } enum EastAsianLineBreakEnum { False, True, NotDefined } enum LatinLineBreakEnum { False, True, NotDefined } enum HangingPunctuationEnum { False, True, NotDefined } enum BulletTypeEnum { None, Symbol, Numbered, Picture, NotDefined } enum NumberedBulletStyleEnum { BulletAlphaLCPeriod, BulletAlphaUCPeriod, BulletArabicParenRight, BulletArabicPeriod, BulletRomanLCParenBoth, BulletRomanLCParenRight, BulletRomanLCPeriod, BulletRomanUCPeriod, BulletAlphaLCParenBoth, BulletAlphaLCParenRight, BulletAlphaUCParenBoth, BulletAlphaUCParenRight, BulletArabicParenBoth, BulletArabicPlain, BulletRomanUCParenBoth, BulletRomanUCParenRight, BulletSimpChinPlain, BulletSimpChinPeriod, BulletCircleNumDBPlain, BulletCircleNumWDWhitePlain, BulletCircleNumWDBlackPlain, BulletTradChinPlain, BulletTradChinPeriod, BulletArabicAlphaDash, BulletArabicAbjadDash, BulletHebrewAlphaDash, BulletKanjiKoreanPlain, BulletKanjiKoreanPeriod, BulletArabicDBPlain, BulletArabicDBPeriod, BulletThaiAlphaPeriod, BulletThaiAlphaParenRight, BulletThaiAlphaParenBoth, BulletThaiNumPeriod, BulletThaiNumParenRight, BulletThaiNumParenBoth, BulletHindiAlphaPeriod, BulletHindiNumPeriod, BulletKanjiSimpChinDBPeriod, BulletHindiNumParenRight, BulletHindiAlpha1Period, NotDefined } } /** * Represents list of Links to Paragraphs resources */ export declare class Paragraphs extends ResourceBase { constructor(); /** * List of paragraph links. */ paragraphLinks?: Array; } /** * Represents input file from filesystem. */ export declare class PathInputFile extends InputFile { constructor(); /** * Get or sets path to file. */ path?: string; /** * Get or sets name of storage. */ storage?: string; } export declare namespace PathInputFile { } /** * Represents fileSystem file with path. */ export declare class PathOutputFile extends OutputFile { constructor(); /** * Get or sets path to file. */ path?: string; /** * Get or sets name of storage. */ storage?: string; } export declare namespace PathOutputFile { } /** * Represents Pattern Fill */ export declare class PatternFill extends FillFormat { constructor(); /** * Gets or sets the back color of the pattern fill. */ backColor?: string; /** * Gets or sets the fore color of the pattern fill. */ foreColor?: string; /** * Gets or sets the style of pattern fill. */ style: PatternFill.StyleEnum; } export declare namespace PatternFill { enum StyleEnum { Unknown, Percent05, Percent10, Percent20, Percent25, Percent30, Percent40, Percent50, Percent60, Percent70, Percent75, Percent80, Percent90, DarkHorizontal, DarkVertical, DarkDownwardDiagonal, DarkUpwardDiagonal, SmallCheckerBoard, Trellis, LightHorizontal, LightVertical, LightDownwardDiagonal, LightUpwardDiagonal, SmallGrid, DottedDiamond, WideDownwardDiagonal, WideUpwardDiagonal, DashedUpwardDiagonal, DashedDownwardDiagonal, NarrowVertical, NarrowHorizontal, DashedVertical, DashedHorizontal, LargeConfetti, LargeGrid, HorizontalBrick, LargeCheckerBoard, SmallConfetti, Zigzag, SolidDiamond, DiagonalBrick, OutlinedDiamond, Plaid, Sphere, Weave, DottedGrid, Divot, Shingle, Wave, Horizontal, Vertical, Cross, DownwardDiagonal, UpwardDiagonal, DiagonalCross, NotDefined } } /** * Provides options that control how a presentation is saved in Pdf format. */ export declare class PdfExportOptions extends ExportOptions { constructor(); /** * Specifies compression type to be used for all textual content in the document. */ textCompression?: PdfExportOptions.TextCompressionEnum; /** * Determines if all characters of font should be embedded or only used subset. */ embedFullFonts?: boolean; /** * Desired conformance level for generated PDF document. */ compliance?: PdfExportOptions.ComplianceEnum; /** * Returns or sets a value determining resolution of images inside PDF document. Property affects on file size, time of export and image quality. The default value is 96. */ sufficientResolution?: number; /** * Returns or sets a value determining the quality of the JPEG images inside PDF document. */ jpegQuality?: number; /** * True to draw black frame around each slide. */ drawSlidesFrame?: boolean; /** * Specifies whether the generated document should include hidden slides or not. Default is false. */ showHiddenSlides?: boolean; /** * True to convert all metafiles used in a presentation to the PNG images. */ saveMetafilesAsPng?: boolean; /** * Setting user password to protect the PDF document. */ password?: string; /** * Determines if Aspose.Slides will embed common fonts for ASCII (33..127 code range) text. Fonts for character codes greater than 127 are always embedded. Common fonts list includes PDF's base 14 fonts and additional user specified fonts. */ embedTrueTypeFontsForASCII?: boolean; /** * Returns or sets an array of user-defined names of font families which Aspose.Slides should consider common. */ additionalCommonFontFamilies?: Array; /** * Slides layouting options */ slidesLayoutOptions?: SlidesLayoutOptions; /** * Image transparent color. */ imageTransparentColor?: string; /** * True to apply specified ImageTransparentColor to an image. */ applyImageTransparent?: boolean; /** * Access permissions that should be granted when the document is opened with user access. Default is AccessPermissions.None. */ accessPermissions?: AccessPermissions; /** * True to hide Ink elements in exported document. */ hideInk?: boolean; /** * True to use ROP operation or Opacity for rendering brush. */ interpretMaskOpAsOpacity?: boolean; /** * True if text should be rasterized as a bitmap and saved to PDF when the font does not support bold styling. This approach can enhance the quality of text in the resulting PDF for certain fonts. */ rasterizeUnsupportedFontStyles?: boolean; /** * True to convert all OLE data from the presentation to embedded files in the resulting PDF. */ includeOleData?: boolean; } export declare namespace PdfExportOptions { enum TextCompressionEnum { None, Flate } enum ComplianceEnum { Pdf15, Pdf16, Pdf17, PdfA1b, PdfA1a, PdfA2b, PdfA2a, PdfA3b, PdfA3a, PdfUa, PdfA2u } } /** * PDF import options. */ export declare class PdfImportOptions { /** * True to detect tables. */ detectTables: boolean; } /** * Specifies an instance of mathematical text that contained within a MathParagraph and starts on its own line. */ export declare class PhantomElement extends MathElement { constructor(); /** * Base element */ base?: MathElement; /** * true if the base element is displayed. */ show?: boolean; /** * true if the the width of the base element should be treated as zero. */ zeroWidth?: boolean; /** * true if the the ascent (height above baseline) of the base element should be treated as zero. */ zeroAsc?: boolean; /** * true if the the descent (depth below baseline) of the base element should be treated as zero. */ zeroDesc?: boolean; /** * true if operators and symbols inside the phantom still affect mathematical spacing around the phantom (as if visible). */ transp?: boolean; } export declare namespace PhantomElement { } /** * Picture fill. */ export declare class PictureFill extends FillFormat { constructor(); /** * Percentage of image height that is cropped from the bottom. */ cropBottom: number; /** * Percentage of image height that is cropped from the left. */ cropLeft: number; /** * Percentage of image height that is cropped from the right. */ cropRight: number; /** * Percentage of image height that is cropped from the top. */ cropTop: number; /** * Picture resolution. */ dpi: number; /** * The horizontal offset of the texture from the shape's origin in points. A positive value moves the texture to the right, while a negative value moves it to the left. */ tileOffsetX?: number; /** * The vertical offset of the texture from the shape's origin in points. A positive value moves the texture down, while a negative value moves it up. */ tileOffsetY?: number; /** * The horizontal scale for the texture fill as a percentage. */ tileScaleX?: number; /** * The vertical scale for the texture fill as a percentage. */ tileScaleY?: number; /** * The way texture is aligned within the shape. This setting controls the starting point of the texture pattern and how it repeats across the shape. */ tileAlignment?: PictureFill.TileAlignmentEnum; /** * Flips the texture tile around its horizontal, vertical or both axis. */ tileFlip?: PictureFill.TileFlipEnum; /** * Internal image link. */ image?: ResourceUri; /** * Base 64 image data. */ base64Data?: string; /** * SVG image data. */ svgData?: string; /** * true to delete picture cropped areas on save. */ deletePictureCroppedAreas?: boolean; /** * true to compress the picture image with the specified resolution (in dpi) on save. */ resolution?: number; /** * Fill mode. */ pictureFillMode: PictureFill.PictureFillModeEnum; /** * Image transform effects. */ imageTransformList?: Array; } export declare namespace PictureFill { enum TileAlignmentEnum { TopLeft, Top, TopRight, Left, Center, Right, BottomLeft, Bottom, BottomRight, NotDefined } enum TileFlipEnum { NoFlip, FlipX, FlipY, FlipBoth, NotDefined } enum PictureFillModeEnum { Tile, Stretch } } /** * Represents PictureFrame resource. */ export declare class PictureFrame extends GeometryShape { constructor(); /** * Fill format. */ pictureFillFormat?: PictureFill; } export declare namespace PictureFrame { } /** * Represents pipeline for one input document. */ export declare class Pipeline { /** * Get or sets input document. */ input?: Input; /** * Get or sets list of tasks representing pipeline. */ tasks?: Array; } /** * Represents placeholder */ export declare class Placeholder extends ResourceBase { constructor(); /** * Index. */ index: number; /** * Orientation. */ orientation: Placeholder.OrientationEnum; /** * Size. */ size: Placeholder.SizeEnum; /** * Placeholder type. */ type: Placeholder.TypeEnum; /** * Shape link. */ shape?: ResourceUri; } export declare namespace Placeholder { enum OrientationEnum { Horizontal, Vertical } enum SizeEnum { Full, Half, Quarter } enum TypeEnum { Title, Body, CenteredTitle, Subtitle, DateAndTime, SlideNumber, Footer, Header, Object, Chart, Table, ClipArt, Diagram, Media, SlideImage, Picture } } /** * Placeholder list. */ export declare class Placeholders extends ResourceBase { constructor(); /** * List for placeholder links. */ placeholderLinks?: Array; } /** * Represents the plot area */ export declare class PlotArea { /** * the X location */ x?: number; /** * the Y location */ y?: number; /** * Width */ width?: number; /** * Height */ height?: number; /** * If layout of the plot area is defined manually specifies whether to layout the plot area by its inside (not including axis and axis labels) or outside. */ layoutTargetType?: PlotArea.LayoutTargetTypeEnum; /** * Get or sets the fill format. */ fillFormat?: FillFormat; /** * Get or sets the effect format. */ effectFormat?: EffectFormat; /** * Get or sets the line format. */ lineFormat?: LineFormat; } export declare namespace PlotArea { enum LayoutTargetTypeEnum { Inner, Outer } } /** * Represents portion resource */ export declare class Portion extends ResourceBase { constructor(); /** * Text. */ text?: string; /** * Math paragraph. */ mathParagraph?: MathParagraph; /** * True for bold font. */ fontBold?: Portion.FontBoldEnum; /** * True for italic font. */ fontItalic?: Portion.FontItalicEnum; /** * Text underline type. */ fontUnderline?: Portion.FontUnderlineEnum; /** * Text strikethrough type. */ strikethroughType?: Portion.StrikethroughTypeEnum; /** * Text capitalization type. */ textCapType?: Portion.TextCapTypeEnum; /** * Superscript or subscript of the text. */ escapement?: number; /** * Intercharacter spacing increment. */ spacing?: number; /** * Font color. */ fontColor?: string; /** * Highlight color. */ highlightColor?: string; /** * Font height. */ fontHeight?: number; /** * True to normalize the text. */ normaliseHeight?: Portion.NormaliseHeightEnum; /** * True if the text proof should be disabled. */ proofDisabled?: Portion.ProofDisabledEnum; /** * True if smart tag should be cleaned. */ smartTagClean?: boolean; /** * Minimal font size for kerning. */ kerningMinimalSize?: number; /** * True if numbers should ignore East-Asian specific vertical text layout. */ kumimoji?: Portion.KumimojiEnum; /** * true to enable spell checking for the portion. */ spellCheck?: boolean; /** * Proving language ID. */ languageId?: string; /** * Alternative proving language ID. */ alternativeLanguageId?: string; /** * True if underline style has own FillFormat properties. */ isHardUnderlineFill?: Portion.IsHardUnderlineFillEnum; /** * True if underline style has own LineFormat properties. */ isHardUnderlineLine?: Portion.IsHardUnderlineLineEnum; /** * Fill format. */ fillFormat?: FillFormat; /** * Effect format. */ effectFormat?: EffectFormat; /** * Line format. */ lineFormat?: LineFormat; /** * Underline fill format. */ underlineFillFormat?: FillFormat; /** * Underline line format. */ underlineLineFormat?: LineFormat; /** * Hyperlink defined for mouse click. */ hyperlinkClick?: Hyperlink; /** * Hyperlink defined for mouse over. */ hyperlinkMouseOver?: Hyperlink; /** * Returns or sets the Latin font info. */ latinFont?: string; /** * Returns or sets the East Asian font info. */ eastAsianFont?: string; /** * Returns or sets the complex script font info. */ complexScriptFont?: string; } export declare namespace Portion { enum FontBoldEnum { False, True, NotDefined } enum FontItalicEnum { False, True, NotDefined } enum FontUnderlineEnum { None, Words, Single, Double, Heavy, Dotted, HeavyDotted, Dashed, HeavyDashed, LongDashed, HeavyLongDashed, DotDash, HeavyDotDash, DotDotDash, HeavyDotDotDash, Wavy, HeavyWavy, DoubleWavy, NotDefined } enum StrikethroughTypeEnum { None, Single, Double, NotDefined } enum TextCapTypeEnum { None, Small, All, NotDefined } enum NormaliseHeightEnum { False, True, NotDefined } enum ProofDisabledEnum { False, True, NotDefined } enum KumimojiEnum { False, True, NotDefined } enum IsHardUnderlineFillEnum { False, True, NotDefined } enum IsHardUnderlineLineEnum { False, True, NotDefined } } /** * Represents portion format. */ export declare class PortionFormat { /** * True for bold font. */ fontBold?: PortionFormat.FontBoldEnum; /** * True for italic font. */ fontItalic?: PortionFormat.FontItalicEnum; /** * Text underline type. */ fontUnderline?: PortionFormat.FontUnderlineEnum; /** * Text strikethrough type. */ strikethroughType?: PortionFormat.StrikethroughTypeEnum; /** * Text capitalization type. */ textCapType?: PortionFormat.TextCapTypeEnum; /** * Superscript or subscript of the text. */ escapement?: number; /** * Intercharacter spacing increment. */ spacing?: number; /** * Font color. */ fontColor?: string; /** * Highlight color. */ highlightColor?: string; /** * Font height. */ fontHeight?: number; /** * True to normalize the text. */ normaliseHeight?: PortionFormat.NormaliseHeightEnum; /** * True if the text proof should be disabled. */ proofDisabled?: PortionFormat.ProofDisabledEnum; /** * True if smart tag should be cleaned. */ smartTagClean?: boolean; /** * Minimal font size for kerning. */ kerningMinimalSize?: number; /** * True if numbers should ignore East-Asian specific vertical text layout. */ kumimoji?: PortionFormat.KumimojiEnum; /** * Proving language ID. */ languageId?: string; /** * Alternative proving language ID. */ alternativeLanguageId?: string; /** * True if underline style has own FillFormat properties. */ isHardUnderlineFill?: PortionFormat.IsHardUnderlineFillEnum; /** * True if underline style has own LineFormat properties. */ isHardUnderlineLine?: PortionFormat.IsHardUnderlineLineEnum; /** * Fill format. */ fillFormat?: FillFormat; /** * Effect format. */ effectFormat?: EffectFormat; /** * Line format. */ lineFormat?: LineFormat; /** * Underline fill format. */ underlineFillFormat?: FillFormat; /** * Underline line format. */ underlineLineFormat?: LineFormat; /** * Hyperlink defined for mouse click. */ hyperlinkClick?: Hyperlink; /** * Hyperlink defined for mouse over. */ hyperlinkMouseOver?: Hyperlink; /** * Returns or sets the Latin font info. */ latinFont?: string; /** * Returns or sets the East Asian font info. */ eastAsianFont?: string; /** * Returns or sets the complex script font info. */ complexScriptFont?: string; /** * true to enable spell checking for the portion. */ spellCheck?: boolean; } export declare namespace PortionFormat { enum FontBoldEnum { False, True, NotDefined } enum FontItalicEnum { False, True, NotDefined } enum FontUnderlineEnum { None, Words, Single, Double, Heavy, Dotted, HeavyDotted, Dashed, HeavyDashed, LongDashed, HeavyLongDashed, DotDash, HeavyDotDash, DotDotDash, HeavyDotDotDash, Wavy, HeavyWavy, DoubleWavy, NotDefined } enum StrikethroughTypeEnum { None, Single, Double, NotDefined } enum TextCapTypeEnum { None, Small, All, NotDefined } enum NormaliseHeightEnum { False, True, NotDefined } enum ProofDisabledEnum { False, True, NotDefined } enum KumimojiEnum { False, True, NotDefined } enum IsHardUnderlineFillEnum { False, True, NotDefined } enum IsHardUnderlineLineEnum { False, True, NotDefined } } /** * Represents list of Links to Paragraphs resources */ export declare class Portions extends ResourceBase { constructor(); /** * List of portion links. */ items?: Array; } /** * Provides options that control how a presentation is saved in PPTX format. */ export declare class PptxExportOptions extends ExportOptions { constructor(); /** * The conformance class to which the PresentationML document conforms. */ conformance?: PptxExportOptions.ConformanceEnum; /** * Specifies whether the ZIP64 format is used for the Presentation document. The default value is Zip64Mode.IfNecessary. */ zip64Mode?: PptxExportOptions.Zip64ModeEnum; /** * True to refresh the presentation thumbnail on save */ refreshThumbnail?: boolean; } export declare namespace PptxExportOptions { enum ConformanceEnum { Ecma376, Iso29500Transitional, Iso29500Strict } enum Zip64ModeEnum { Never, IfNecessary, Always } } /** * Represents presentation to merge */ export declare class PresentationToMerge { /** * Get or sets the presentation path */ path?: string; /** * Get or sets the presentation password */ password?: string; /** * Get or sets the indexes of slides to merge */ slides?: Array; /** * Merge (request or storage). */ source?: PresentationToMerge.SourceEnum; } export declare namespace PresentationToMerge { enum SourceEnum { Storage, Request, Url } } /** * Request for presentations merge */ export declare class PresentationsMergeRequest { /** * Gets or sets the presentation paths. */ presentationPaths?: Array; /** * Gets or sets the presentation passwords. */ presentationPasswords?: Array; } /** * Represents preset shadow effect */ export declare class PresetShadowEffect { /** * direction */ direction: number; /** * distance */ distance: number; /** * preset */ preset: PresetShadowEffect.PresetEnum; /** * shadow color */ shadowColor?: string; } export declare namespace PresetShadowEffect { enum PresetEnum { TopLeftDropShadow, TopLeftLargeDropShadow, BackLeftLongPerspectiveShadow, BackRightLongPerspectiveShadow, TopLeftDoubleDropShadow, BottomRightSmallDropShadow, FrontLeftLongPerspectiveShadow, FrontRightLongPerspectiveShadow, OuterBoxShadow3D, InnerBoxShadow3D, BackCenterPerspectiveShadow, TopRightDropShadow, FrontBottomShadow, BackLeftPerspectiveShadow, BackRightPerspectiveShadow, BottomLeftDropShadow, BottomRightDropShadow, FrontLeftPerspectiveShadow, FrontRightPerspectiveShadow, TopLeftSmallDropShadow } } /** * Protection properties. */ export declare class ProtectionProperties extends ResourceBase { constructor(); /** * True if document properties are encrypted. Has effect only for password protected presentations. */ encryptDocumentProperties?: boolean; /** * True if the document should be opened as read-only. */ readOnlyRecommended?: boolean; /** * Password for read protection. */ readPassword?: string; /** * Password for write protection. */ writePassword?: string; /** * Returns true if the presentation protected for editing. */ isWriteProtected?: boolean; /** * Returns true if the presentation protected for reading. */ isEncrypted?: boolean; } /** * Quadratic Bezier curve segment of the geometry path */ export declare class QuadraticBezierToPathSegment extends PathSegment { constructor(); /** * X coordinate of direction point */ x1: number; /** * Y coordinate of direction point */ y1: number; /** * X coordinate of end point */ x2: number; /** * Y coordinate of end point */ y2: number; } export declare namespace QuadraticBezierToPathSegment { } /** * Radical function */ export declare class RadicalElement extends MathElement { constructor(); /** * Base argument */ base?: MathElement; /** * Degree argument */ degree?: MathElement; /** * Hide degree */ hideDegree?: boolean; } export declare namespace RadicalElement { } /** * Represents reflection effect */ export declare class ReflectionEffect { /** * direction */ direction: number; /** * fade direction */ fadeDirection: number; /** * distance */ distance: number; /** * blur radius */ blurRadius: number; /** * scale horizontal */ scaleHorizontal: number; /** * scale vertical */ scaleVertical: number; /** * skew horizontal */ skewHorizontal: number; /** * skew vertical */ skewVertical: number; /** * start pos alpha */ startPosAlpha: number; /** * end pos alpha */ endPosAlpha: number; /** * start reflection opacity */ startReflectionOpacity: number; /** * end reflection opacity */ endReflectionOpacity: number; /** * rectangle alignment */ rectangleAlign: ReflectionEffect.RectangleAlignEnum; /** * true if the reflection should rotate with the shape when the shape is rotated */ rotateShadowWithShape: boolean; } export declare namespace ReflectionEffect { enum RectangleAlignEnum { TopLeft, Top, TopRight, Left, Center, Right, BottomLeft, Bottom, BottomRight, NotDefined } } /** * Remove shape task. */ export declare class RemoveShape extends Task { constructor(); /** * Shape path for a grouped or smart art shape. */ shapePath?: string; } export declare namespace RemoveShape { } /** * Remove slide task. */ export declare class RemoveSlide extends Task { constructor(); /** * Position of slide to be removed. */ position: number; } export declare namespace RemoveSlide { } /** * Reorder slide task. */ export declare class ReorderSlide extends Task { constructor(); /** * Old position. */ oldPosition: number; /** * New position. */ newPosition: number; } export declare namespace ReorderSlide { } /** * Replace text task. */ export declare class ReplaceText extends Task { constructor(); /** * Text to be replaced. */ oldText?: string; /** * Text to replace with. */ newText?: string; /** * True to ignore case in replace pattern search. */ ignoreCase: boolean; /** * One-based position of the slide to perform the replace in. 0 to make the replace throughout the presentation. */ slidePosition: number; } export declare namespace ReplaceText { } /** * Represents input file from multipart request. */ export declare class RequestInputFile extends InputFile { constructor(); /** * Get or sets index of file from request. */ index: number; } export declare namespace RequestInputFile { } /** * Reset slide task. */ export declare class ResetSlide extends Task { constructor(); /** * Slide position. */ position: number; } export declare namespace ResetSlide { } /** * Represents Resource URI */ export declare class ResourceUri { /** * Gets or sets the href. */ href?: string; /** * Gets or sets the relation. */ relation?: string; /** * Gets or sets the type of link. */ linkType?: string; /** * Gets or sets the title of link. */ title?: string; /** * Resource slide index. */ slideIndex?: number; /** * Resource shape index. */ shapeIndex?: number; } /** * Represents output file that will be sent to response. */ export declare class ResponseOutputFile extends OutputFile { constructor(); } export declare namespace ResponseOutputFile { } /** * Specifies the Sub-Superscript object */ export declare class RightSubSuperscriptElement extends MathElement { constructor(); /** * Base argument */ base?: MathElement; /** * Subscript */ subscript?: MathElement; /** * Superscript */ superscript?: MathElement; /** * Alignment of subscript/superscript. */ alignScripts?: boolean; } export declare namespace RightSubSuperscriptElement { } /** * Save slide task. */ export declare class Save extends Task { constructor(); /** * Format. */ format: Save.FormatEnum; /** * Output file. */ output?: OutputFile; /** * Save options. */ options?: ExportOptions; } export declare namespace Save { enum FormatEnum { Pdf, Xps, Tiff, Pptx, Odp, Otp, Ppt, Pps, Ppsx, Pptm, Ppsm, Pot, Potx, Potm, Html, Html5, Swf, Svg, Jpeg, Png, Gif, Bmp, Fodp, Xaml, Mpeg4, Md, Xml, Emf } } /** * Save shape task. */ export declare class SaveShape extends Task { constructor(); /** * Format. */ format: SaveShape.FormatEnum; /** * Shape path. */ shapePath?: string; /** * Output file. */ output?: OutputFile; /** * Save options. */ options?: IShapeExportOptions; } export declare namespace SaveShape { enum FormatEnum { Jpeg, Png, Gif, Bmp, Tiff, Svg, Emf } } /** * Save slide task. */ export declare class SaveSlide extends Task { constructor(); /** * Output to save the slide to. */ output?: OutputFile; /** * Save format. */ format: SaveSlide.FormatEnum; /** * Save options. */ options?: ExportOptions; /** * Result width for saving to an image format. */ width?: number; /** * Result height for saving to an image format. */ height?: number; /** * Slide index. */ position: number; } export declare namespace SaveSlide { enum FormatEnum { Jpeg, Png, Gif, Bmp, Tiff, Html, Pdf, Xps, Pptx, Odp, Otp, Ppt, Pps, Ppsx, Pptm, Ppsm, Potx, Pot, Potm, Svg, Fodp, Xaml, Html5, Md, Xml, Emf } } /** * A scatter series */ export declare class ScatterSeries extends XYSeries { constructor(); /** * Gets or sets the values. */ dataPoints?: Array; } export declare namespace ScatterSeries { } /** * Presentation section. */ export declare class Section extends ResourceBase { constructor(); /** * Name. */ name?: string; /** * One-based index of slide with which the section starts. */ firstSlideIndex: number; /** * Links to the shapes contained in the section. */ slideList?: Array; } /** * Zoom object. */ export declare class ZoomObject extends ShapeBase { constructor(); /** * Image type of a zoom object. */ imageType?: ZoomObject.ImageTypeEnum; /** * Navigation behavior in slideshow. */ returnToParent?: boolean; /** * Specifies whether the Zoom will use the background of the destination slide. */ showBackground?: boolean; /** * Internal image link for zoom object */ image?: ResourceUri; /** * Duration of the transition between Zoom and slide. */ transitionDuration?: number; } export declare namespace ZoomObject { enum ImageTypeEnum { Preview, Cover } } /** * Section zoom frame. */ export declare class SectionZoomFrame extends ZoomObject { constructor(); /** * Index of the target section */ targetSectionIndex?: number; } export declare namespace SectionZoomFrame { } /** * Section list. */ export declare class Sections extends ResourceBase { constructor(); /** * List of slide links. */ sectionList?: Array
; } /** * Represents a series marker */ export declare class SeriesMarker { /** * size */ size?: number; /** * symbol */ symbol?: SeriesMarker.SymbolEnum; /** * Get or sets the fill format. */ fillFormat?: FillFormat; /** * Get or sets the effect format. */ effectFormat?: EffectFormat; /** * Get or sets the line format. */ lineFormat?: LineFormat; } export declare namespace SeriesMarker { enum SymbolEnum { Circle, Dash, Diamond, Dot, None, Picture, Plus, Square, Star, Triangle, X, NotDefined } } /** * Represents AutoShape resource. */ export declare class Shape extends GeometryShape { constructor(); /** * Gets or sets the text. */ text?: string; /** * Get or sets list to paragraphs list */ paragraphs?: Array; /** * Returns TextFrame's formatting properties. */ textFrameFormat?: TextFrameFormat; } export declare namespace Shape { } /** * ShapeBevel */ export declare class ShapeBevel { /** * Bevel type */ bevelType?: ShapeBevel.BevelTypeEnum; /** * Bevel width */ width?: number; /** * Bevel height */ height?: number; } export declare namespace ShapeBevel { enum BevelTypeEnum { Angle, ArtDeco, Circle, Convex, CoolSlant, Cross, Divot, HardEdge, RelaxedInset, Riblet, Slope, SoftRound, NotDefined } } /** * Represents a format for individual shape export. */ /** * Represents a format for individual shape export. */ export declare enum ShapeExportFormat { 'Jpeg', 'Png', 'Gif', 'Bmp', 'Tiff', 'Svg', 'Emf' } /** * Provides options that control how a shape is saved in thumbnail. */ export declare class ShapeImageExportOptions { /** * Get or sets scaling ratio by X axis. */ scaleX?: number; /** * Get or sets scaling ratio by Y axis. */ scaleY?: number; /** * Get or sets thumbnail bounds */ thumbnailBounds?: ShapeImageExportOptions.ThumbnailBoundsEnum; /** * Gets export format. */ format?: string; } export declare namespace ShapeImageExportOptions { enum ThumbnailBoundsEnum { Slide, Shape, Appearance } } /** * Represents thumnail bounds settings. */ /** * Represents thumnail bounds settings. */ export declare enum ShapeThumbnailBounds { 'Slide', 'Shape', 'Appearance' } /** * Shape type */ /** * Shape type */ export declare enum ShapeType { 'Shape', 'Chart', 'Table', 'PictureFrame', 'VideoFrame', 'AudioFrame', 'SmartArt', 'OleObjectFrame', 'GroupShape', 'GraphicalObject', 'Connector', 'SmartArtShape', 'ZoomFrame', 'SectionZoomFrame', 'SummaryZoomFrame', 'SummaryZoomSection' } /** * Represents list of Links to Shapes resources */ export declare class Shapes extends ResourceBase { constructor(); /** * List of shape links. */ shapesLinks?: Array; } /** * */ /** * */ export declare enum ShapesAlignmentType { 'AlignLeft', 'AlignRight', 'AlignCenter', 'AlignTop', 'AlignMiddle', 'AlignBottom', 'DistributeHorizontally', 'DistributeVertically' } /** * Presentation slide. */ export declare class Slide extends ResourceBase { constructor(); /** * Gets or sets the width. */ width: number; /** * Gets or sets the height. */ height: number; /** * Specifies if shapes of the master slide should be shown on the slide. True by default. */ showMasterShapes?: boolean; /** * Specifies if shapes of the master slide should be shown on the slide. True by default. */ slideShowTransition?: SlideShowTransition; /** * Gets or sets the link to the layout slide. */ layoutSlide?: ResourceUri; /** * Gets or sets the link to list of top-level shapes. */ shapes?: ResourceUri; /** * Gets or sets the link to theme. */ theme?: ResourceUri; /** * Gets or sets the link to placeholders. */ placeholders?: ResourceUri; /** * Gets or sets the link to images. */ images?: ResourceUri; /** * Gets or sets the link to comments. */ comments?: ResourceUri; /** * Get or sets the link to slide's background */ background?: ResourceUri; /** * Get or sets the link to notes slide. */ notesSlide?: ResourceUri; } /** * Represents comments collection of slide */ export declare class SlideAnimation extends ResourceBase { constructor(); /** * Main sequence. */ mainSequence?: Array; /** * Interactive sequence list. */ interactiveSequences?: Array; } /** * Represents background of slide */ export declare class SlideBackground extends ResourceBase { constructor(); /** * Fill type. */ type: SlideBackground.TypeEnum; /** * Fill format. */ fillFormat?: FillFormat; /** * Effect format. */ effectFormat?: EffectFormat; } export declare namespace SlideBackground { enum TypeEnum { NoFill, Solid, Gradient, Pattern, Picture, NotDefined } } /** * Represents slide comment */ export declare class SlideCommentBase { /** * Author. */ author?: string; /** * Text. */ text?: string; /** * Creation time. */ createdTime?: string; /** * Child comments. */ childComments?: Array; type?: SlideCommentBase.TypeEnum; } export declare namespace SlideCommentBase { enum TypeEnum { Regular, Modern } } /** * Represents comment of slide */ export declare class SlideComment extends SlideCommentBase { constructor(); } export declare namespace SlideComment { } /** * Represents comments collection of slide */ export declare class SlideComments extends ResourceBase { constructor(); /** * Slide comment list. */ list?: Array; } /** * Slide Export Format */ /** * Slide Export Format */ export declare enum SlideExportFormat { 'Jpeg', 'Png', 'Gif', 'Bmp', 'Tiff', 'Html', 'Pdf', 'Xps', 'Pptx', 'Odp', 'Otp', 'Ppt', 'Pps', 'Ppsx', 'Pptm', 'Ppsm', 'Potx', 'Pot', 'Potm', 'Svg', 'Fodp', 'Xaml', 'Html5', 'Md', 'Xml', 'Emf' } /** * Represents modern comment of slide */ export declare class SlideModernComment extends SlideCommentBase { constructor(); /** * Returns or sets starting position of text selection in text frame if the comment associated with AutoShape. Read/write Int32. */ textSelectionStart?: number; /** * Returns or sets text selection length in text frame if the comment associated with AutoShape. Read/write Int32. */ textSelectionLength?: number; /** * Returns or sets the status of the comment. Read/write ModernCommentStatus. */ status?: SlideModernComment.StatusEnum; } export declare namespace SlideModernComment { enum StatusEnum { NotDefined, Active, Resolved, Closed } } /** * Slide properties. */ export declare class SlideProperties extends ResourceBase { constructor(); /** * First slide number. */ firstSlideNumber?: number; /** * Slide orientation. */ orientation?: SlideProperties.OrientationEnum; /** * Scale type. */ scaleType?: SlideProperties.ScaleTypeEnum; /** * Size type. */ sizeType?: SlideProperties.SizeTypeEnum; /** * Width. */ width?: number; /** * Height. */ height?: number; } export declare namespace SlideProperties { enum OrientationEnum { Landscape, Portrait } enum ScaleTypeEnum { DoNotScale, EnsureFit, Maximize } enum SizeTypeEnum { OnScreen, LetterPaper, A4Paper, Slide35mm, Overhead, Banner, Custom, Ledger, A3Paper, B4IsoPaper, B5IsoPaper, B4JisPaper, B5JisPaper, HagakiCard, OnScreen16x9, OnScreen16x10, Widescreen } } /** * Represents slide replace result DTO. */ export declare class SlideReplaceResult extends Slide { constructor(); /** * Gets or sets the number of matches */ matches: number; } /** * Slide show properties. */ export declare class SlideShowProperties extends ResourceBase { constructor(); /** * Loop slide show. */ loop?: boolean; /** * Start slide in the slide show. */ startSlide?: number; /** * End slides in the slide show. */ endSlide?: number; /** * Pen color. */ penColor?: string; /** * Show animation. */ showAnimation?: boolean; /** * Show narrration. */ showNarration?: boolean; /** * Show media controls. */ showMediaControls?: boolean; /** * Use timings. */ useTimings?: boolean; /** * Slide show type. */ slideShowType?: SlideShowProperties.SlideShowTypeEnum; /** * Show scroll bar. Applied with BrowsedByIndividual slide show type. */ showScrollbar?: boolean; } export declare namespace SlideShowProperties { enum SlideShowTypeEnum { BrowsedAtKiosk, BrowsedByIndividual, PresentedBySpeaker } } /** * Slide Show Transition. */ export declare class SlideShowTransition { /** * Transition Type */ type?: SlideShowTransition.TypeEnum; /** * Advance After */ advanceAfter?: boolean; /** * Advance After Time */ advanceAfterTime?: number; /** * Advance On Click */ advanceOnClick?: boolean; /** * Sound Is Built In */ soundIsBuiltIn?: boolean; /** * Sound Loop */ soundLoop?: boolean; /** * Sound Mode */ soundMode?: SlideShowTransition.SoundModeEnum; /** * Sound Name */ soundName?: string; /** * Speed */ speed?: SlideShowTransition.SpeedEnum; /** * Corner Direction. */ cornerDirection?: SlideShowTransition.CornerDirectionEnum; /** * Eight Direction. */ eightDirection?: SlideShowTransition.EightDirectionEnum; /** * In/Out Direction. */ inOutDirection?: SlideShowTransition.InOutDirectionEnum; /** * Has Bounce. */ hasBounce?: boolean; /** * Side Direction. */ sideDirection?: SlideShowTransition.SideDirectionEnum; /** * Pattern. */ pattern?: SlideShowTransition.PatternEnum; /** * Left/Right Direction. */ leftRightDirection?: SlideShowTransition.LeftRightDirectionEnum; /** * Morph Type. */ morphType?: SlideShowTransition.MorphTypeEnum; /** * From Black. */ fromBlack?: boolean; /** * Orientation Direction. */ orientationDirection?: SlideShowTransition.OrientationDirectionEnum; /** * Through Black. */ throughBlack?: boolean; /** * Orientation. */ cornerAndCenterDirection?: SlideShowTransition.CornerAndCenterDirectionEnum; /** * Shred Pattern. */ shredPattern?: SlideShowTransition.ShredPatternEnum; /** * Orientation. */ orientation?: SlideShowTransition.OrientationEnum; /** * Spokes. */ spokes?: number; /** * The duration of the slide transition effect in milliseconds. If not set, the duration is determined automatically based on Speed and Type values. */ duration?: number; } export declare namespace SlideShowTransition { enum TypeEnum { None, Blinds, Checker, Circle, Comb, Cover, Cut, Diamond, Dissolve, Fade, Newsflash, Plus, Pull, Push, Random, RandomBar, Split, Strips, Wedge, Wheel, Wipe, Zoom, Vortex, Switch, Flip, Ripple, Honeycomb, Cube, Box, Rotate, Orbit, Doors, Window, Ferris, Gallery, Conveyor, Pan, Glitter, Warp, Flythrough, Flash, Shred, Reveal, WheelReverse, FallOver, Drape, Curtains, Wind, Prestige, Fracture, Crush, PeelOff, PageCurlDouble, PageCurlSingle, Airplane, Origami, Morph } enum SoundModeEnum { StartSound, StopPrevoiusSound, NotDefined } enum SpeedEnum { Fast, Medium, Slow } enum CornerDirectionEnum { LeftDown, LeftUp, RightDown, RightUp } enum EightDirectionEnum { LeftDown, LeftUp, RightDown, RightUp, Left, Up, Down, Right } enum InOutDirectionEnum { In, Out } enum SideDirectionEnum { Left, Up, Down, Right } enum PatternEnum { Diamond, Hexagon } enum LeftRightDirectionEnum { Left, Right } enum MorphTypeEnum { ByObject, ByWord, ByChar } enum OrientationDirectionEnum { Horizontal, Vertical } enum CornerAndCenterDirectionEnum { LeftDown, LeftUp, RightDown, RightUp, Center } enum ShredPatternEnum { Strip, Rectangle } enum OrientationEnum { Horizontal, Vertical } } /** * Slide list. */ export declare class Slides extends ResourceBase { constructor(); /** * List of slide links. */ slideList?: Array; } /** * Represents SmartArt shape resource. */ export declare class SmartArt extends ShapeBase { constructor(); /** * Layout type. */ layout: SmartArt.LayoutEnum; /** * Quick style. */ quickStyle: SmartArt.QuickStyleEnum; /** * Color style. */ colorStyle: SmartArt.ColorStyleEnum; /** * Collection of nodes in SmartArt object. */ nodes?: Array; /** * The state of the SmartArt diagram with regard to (left-to-right) LTR or (right-to-left) RTL, if the diagram supports reversal. */ isReversed?: boolean; } export declare namespace SmartArt { enum LayoutEnum { AccentProcess, AccentedPicture, AlternatingFlow, AlternatingHexagons, AlternatingPictureBlocks, AlternatingPictureCircles, ArrowRibbon, AscendingPictureAccentProcess, Balance, BasicBendingProcess, BasicBlockList, BasicChevronProcess, BasicCycle, BasicMatrix, BasicPie, BasicProcess, BasicPyramid, BasicRadial, BasicTarget, BasicTimeline, BasicVenn, BendingPictureAccentList, BendingPictureBlocks, BendingPictureCaption, BendingPictureCaptionList, BendingPictureSemiTransparentText, BlockCycle, BubblePictureList, CaptionedPictures, ChevronList, CircleAccentTimeline, CircleArrowProcess, CirclePictureHierarchy, CircleRelationship, CircularBendingProcess, CircularPictureCallout, ClosedChevronProcess, ContinuousArrowProcess, ContinuousBlockProcess, ContinuousCycle, ContinuousPictureList, ConvergingArrows, ConvergingRadial, CounterbalanceArrows, CycleMatrix, DescendingBlockList, DescendingProcess, DetailedProcess, DivergingArrows, DivergingRadial, Equation, FramedTextPicture, Funnel, Gear, GridMatrix, GroupedList, HalfCircleOrganizationChart, HexagonCluster, Hierarchy, HierarchyList, HorizontalBulletList, HorizontalHierarchy, HorizontalLabeledHierarchy, HorizontalMultiLevelHierarchy, HorizontalOrganizationChart, HorizontalPictureList, IncreasingArrowsProcess, IncreasingCircleProcess, InvertedPyramid, LabeledHierarchy, LinearVenn, LinedList, MultidirectionalCycle, NameandTitleOrganizationChart, NestedTarget, NondirectionalCycle, OpposingArrows, OpposingIdeas, OrganizationChart, PhasedProcess, PictureAccentBlocks, PictureAccentList, PictureAccentProcess, PictureCaptionList, PictureGrid, PictureLineup, PictureStrips, PieProcess, PlusandMinus, ProcessArrows, ProcessList, PyramidList, RadialCluster, RadialCycle, RadialList, RadialVenn, RandomToResultProcess, RepeatingBendingProcess, ReverseList, SegmentedCycle, SegmentedProcess, SegmentedPyramid, SnapshotPictureList, SpiralPicture, SquareAccentList, StackedList, StackedVenn, StaggeredProcess, StepDownProcess, StepUpProcess, SubStepProcess, TableHierarchy, TableList, TargetList, TextCycle, TitlePictureLineup, TitledMatrix, TitledPictureAccentList, TitledPictureBlocks, TrapezoidList, UpwardArrow, VerticalAccentList, VerticalArrowList, VerticalBendingProcess, VerticalBlockList, VerticalBoxList, VerticalBulletList, VerticalChevronList, VerticalCircleList, VerticalCurvedList, VerticalEquation, VerticalPictureAccentList, VerticalPictureList, VerticalProcess, Custom, PictureOrganizationChart } enum QuickStyleEnum { SimpleFill, WhiteOutline, SubtleEffect, ModerateEffect, IntenceEffect, Polished, Inset, Cartoon, Powder, BrickScene, FlatScene, MetallicScene, SunsetScene, BirdsEyeScene } enum ColorStyleEnum { Dark1Outline, Dark2Outline, DarkFill, ColorfulAccentColors, ColorfulAccentColors2to3, ColorfulAccentColors3to4, ColorfulAccentColors4to5, ColorfulAccentColors5to6, ColoredOutlineAccent1, ColoredFillAccent1, GradientRangeAccent1, GradientLoopAccent1, TransparentGradientRangeAccent1, ColoredOutlineAccent2, ColoredFillAccent2, GradientRangeAccent2, GradientLoopAccent2, TransparentGradientRangeAccent2, ColoredOutlineAccent3, ColoredFillAccent3, GradientRangeAccent3, GradientLoopAccent3, TransparentGradientRangeAccent3, ColoredOutlineAccent4, ColoredFillAccent4, GradientRangeAccent4, GradientLoopAccent4, TransparentGradientRangeAccent4, ColoredOutlineAccent5, ColoredFillAccent5, GradientRangeAccent5, GradientLoopAccent5, TransparentGradientRangeAccent5, ColoredOutlineAccent6, ColoredFillAccent6, GradientRangeAccent6, GradientLoopAccent6, TransparentGradientRangeAccent6 } } /** * Smart art node. */ export declare class SmartArtNode { /** * Node list. */ nodes?: Array; /** * Gets or sets the link to shapes. */ shapes?: ResourceUri; /** * True for and assistant node. */ isAssistant?: boolean; /** * Node text. */ text?: string; /** * Organization chart layout type associated with current node. */ orgChartLayout: SmartArtNode.OrgChartLayoutEnum; /** * Get or sets list to paragraphs list */ paragraphs?: ResourceUri; } export declare namespace SmartArtNode { enum OrgChartLayoutEnum { Initial, Standart, BothHanging, LeftHanging, RightHanging } } /** * Represents SmartArt resource. */ export declare class SmartArtShape extends GeometryShape { constructor(); } export declare namespace SmartArtShape { } /** * Represents soft edge effect */ export declare class SoftEdgeEffect { /** * radius */ radius: number; } /** * Represents solid fill format */ export declare class SolidFill extends FillFormat { constructor(); /** * Color. */ color?: string; } export declare namespace SolidFill { } /** * */ /** * */ export declare enum SpecialSlideType { 'MasterSlide', 'LayoutSlide', 'NotesSlide' } /** * Split document result. */ export declare class SplitDocumentResult extends ResourceBase { constructor(); /** * List of slide links. */ slides?: Array; } /** * Storage exists */ export declare class StorageExist { /** * Shows that the storage exists. */ exists: boolean; } /** * Subscript object */ export declare class SubscriptElement extends MathElement { constructor(); /** * Base argument */ base?: MathElement; /** * Subscript */ subscript?: MathElement; } export declare namespace SubscriptElement { } /** * Summary zoom frame. */ export declare class SummaryZoomFrame extends ShapeBase { constructor(); /** * Zoom layout type */ zoomLayout?: SummaryZoomFrame.ZoomLayoutEnum; /** * Zoom frame sections */ sections?: Array; } export declare namespace SummaryZoomFrame { enum ZoomLayoutEnum { GridLayout, FixedLayout } } /** * Represents summary zoom section */ export declare class SummaryZoomSection extends SectionZoomFrame { constructor(); /** * Section title */ title?: string; /** * Description of the Summary Zoom Section object. */ description?: string; } export declare namespace SummaryZoomSection { } /** * Subscript object */ export declare class SuperscriptElement extends MathElement { constructor(); /** * Base argument */ base?: MathElement; /** * Superscript */ superscript?: MathElement; } export declare namespace SuperscriptElement { } /** * Provides options that control how a presentation is saved in SVG format. */ export declare class SvgExportOptions extends ExportOptions { constructor(); /** * Determines whether the text on a slide will be saved as graphics. */ vectorizeText?: boolean; /** * Returns or sets the lower resolution limit for metafile rasterization. */ metafileRasterizationDpi?: number; /** * Determines whether the 3D text is disabled in SVG. */ disable3DText?: boolean; /** * Disables splitting FromCornerX and FromCenter gradients. */ disableGradientSplit?: boolean; /** * SVG 1.1 lacks ability to define insets for markers. Aspose.Slides SVG writing engine has workaround for that problem: it crops end of line with arrow, so, line doesn't overlap markers. This option switches off such behavior. */ disableLineEndCropping?: boolean; /** * Determines JPEG encoding quality. */ jpegQuality?: number; /** * Represents the pictures compression level */ picturesCompression?: SvgExportOptions.PicturesCompressionEnum; /** * A boolean flag indicates if the cropped parts remain as part of the document. If true the cropped parts will removed, if false they will be serialized in the document (which can possible lead to a larger file) */ deletePicturesCroppedAreas?: boolean; /** * Determines a way of handling externally loaded fonts. */ externalFontsHandling?: SvgExportOptions.ExternalFontsHandlingEnum; /** * Determines whether the text frame will be included in a rendering area or not. */ useFrameSize?: boolean; /** * Determines whether to perform the specified rotation of the shape when rendering or not. */ useFrameRotation?: boolean; /** * true to disable ligatures in the rendered output. */ disableFontLigatures?: boolean; } export declare namespace SvgExportOptions { enum PicturesCompressionEnum { Dpi330, Dpi220, Dpi150, Dpi96, Dpi72, DocumentResolution } enum ExternalFontsHandlingEnum { AddLinksToFontFiles, Embed, Vectorize } } /** * Provides options that control how a presentation is saved in SWF format. */ export declare class SwfExportOptions extends ExportOptions { constructor(); /** * Specifies whether the generated document should include hidden slides or not. Default is false. */ showHiddenSlides?: boolean; /** * Specifies whether the generated SWF document should be compressed or not. Default is true. */ compressed?: boolean; /** * Specifies whether the generated SWF document should include the integrated document viewer or not. Default is true. */ viewerIncluded?: boolean; /** * Specifies whether border around pages should be shown. Default is true. */ showPageBorder?: boolean; /** * Show/hide fullscreen button. Can be overridden in flashvars. Default is true. */ showFullScreen?: boolean; /** * Show/hide page stepper. Can be overridden in flashvars. Default is true. */ showPageStepper?: boolean; /** * Show/hide search section. Can be overridden in flashvars. Default is true. */ showSearch?: boolean; /** * Show/hide whole top pane. Can be overridden in flashvars. Default is true. */ showTopPane?: boolean; /** * Show/hide bottom pane. Can be overridden in flashvars. Default is true. */ showBottomPane?: boolean; /** * Show/hide left pane. Can be overridden in flashvars. Default is true. */ showLeftPane?: boolean; /** * Start with opened left pane. Can be overridden in flashvars. Default is false. */ startOpenLeftPane?: boolean; /** * Enable/disable context menu. Default is true. */ enableContextMenu?: boolean; /** * Image that will be displayed as logo in the top right corner of the viewer. The image data is a base 64 string. Image should be 32x64 pixels PNG image, otherwise logo can be displayed improperly. */ logoImage?: string; /** * Gets or sets the full hyperlink address for a logo. Has an effect only if a LogoImage is specified. */ logoLink?: string; /** * Specifies the quality of JPEG images. Default is 95. */ jpegQuality?: number; /** * Slides layouting options */ slidesLayoutOptions?: SlidesLayoutOptions; } export declare namespace SwfExportOptions { } /** * Represents Table shape resource. */ export declare class Table extends ShapeBase { constructor(); /** * Builtin table style. */ style?: Table.StyleEnum; /** * Rows. */ rows?: Array; /** * Columns. */ columns?: Array; /** * Determines whether the first column of a table has to be drawn with a special formatting. */ firstCol?: boolean; /** * Determines whether the first row of a table has to be drawn with a special formatting. */ firstRow?: boolean; /** * Determines whether the even rows has to be drawn with a different formatting. */ horizontalBanding?: boolean; /** * Determines whether the last column of a table has to be drawn with a special formatting. */ lastCol?: boolean; /** * Determines whether the last row of a table has to be drawn with a special formatting. */ lastRow?: boolean; /** * Determines whether the table has right to left reading order. */ rightToLeft?: boolean; /** * Determines whether the even columns has to be drawn with a different formatting. */ verticalBanding?: boolean; /** * Transparency. */ transparency?: number; } export declare namespace Table { enum StyleEnum { None, MediumStyle2Accent1, MediumStyle2, NoStyleNoGrid, ThemedStyle1Accent1, ThemedStyle1Accent2, ThemedStyle1Accent3, ThemedStyle1Accent4, ThemedStyle1Accent5, ThemedStyle1Accent6, NoStyleTableGrid, ThemedStyle2Accent1, ThemedStyle2Accent2, ThemedStyle2Accent3, ThemedStyle2Accent4, ThemedStyle2Accent5, ThemedStyle2Accent6, LightStyle1, LightStyle1Accent1, LightStyle1Accent2, LightStyle1Accent3, LightStyle1Accent4, LightStyle2Accent5, LightStyle1Accent6, LightStyle2, LightStyle2Accent1, LightStyle2Accent2, LightStyle2Accent3, MediumStyle2Accent3, MediumStyle2Accent4, MediumStyle2Accent5, LightStyle2Accent6, LightStyle2Accent4, LightStyle3, LightStyle3Accent1, MediumStyle2Accent2, LightStyle3Accent2, LightStyle3Accent3, LightStyle3Accent4, LightStyle3Accent5, LightStyle3Accent6, MediumStyle1, MediumStyle1Accent1, MediumStyle1Accent2, MediumStyle1Accent3, MediumStyle1Accent4, MediumStyle1Accent5, MediumStyle1Accent6, MediumStyle2Accent6, MediumStyle3, MediumStyle3Accent1, MediumStyle3Accent2, MediumStyle3Accent3, MediumStyle3Accent4, MediumStyle3Accent5, MediumStyle3Accent6, MediumStyle4, MediumStyle4Accent1, MediumStyle4Accent2, MediumStyle4Accent3, MediumStyle4Accent4, MediumStyle4Accent5, MediumStyle4Accent6, DarkStyle1, DarkStyle1Accent1, DarkStyle1Accent2, DarkStyle1Accent3, DarkStyle1Accent4, DarkStyle1Accent5, DarkStyle1Accent6, DarkStyle2, DarkStyle2Accent1Accent2, DarkStyle2Accent3Accent4, DarkStyle2Accent5Accent6, LightStyle1Accent5, Custom } } /** * Represents one cell of table. */ export declare class TableCell { /** * Cell text. */ text?: string; /** * The number of rows spanned by a merged cell. */ rowSpan?: number; /** * The number of columns spanned by a merged cell. */ colSpan?: number; /** * The top margin of the cell. */ marginTop?: number; /** * The right margin of the cell. */ marginRight?: number; /** * The left margin of the cell. */ marginLeft?: number; /** * The bottom margin of the cell. */ marginBottom?: number; /** * Transparency. */ transparency?: number; /** * Text anchor type. */ textAnchorType?: TableCell.TextAnchorTypeEnum; /** * The type of vertical text. */ textVerticalType?: TableCell.TextVerticalTypeEnum; /** * Fill properties set of the cell. */ fillFormat?: FillFormat; /** * Line properties set for the top border of the cell. */ borderTop?: LineFormat; /** * Line properties set for the right border of the cell. */ borderRight?: LineFormat; /** * Line properties set for the left border of the cell. */ borderLeft?: LineFormat; /** * Line properties set for the bottom border of the cell. */ borderBottom?: LineFormat; /** * Line properties set for the diagonal up border of the cell. */ borderDiagonalUp?: LineFormat; /** * Line properties set for the diagonal down border of the cell. */ borderDiagonalDown?: LineFormat; /** * Cell column index */ columnIndex?: number; /** * Cell row index */ rowIndex?: number; /** * Returns TextFrame's formatting properties. */ textFrameFormat?: TextFrameFormat; /** * Get or sets list to paragraphs list */ paragraphs?: ResourceUri; } export declare namespace TableCell { enum TextAnchorTypeEnum { Top, Center, Bottom, Justified, Distributed, NotDefined } enum TextVerticalTypeEnum { Horizontal, Vertical, Vertical270, WordArtVertical, EastAsianVertical, MongolianVertical, WordArtVerticalRightToLeft, NotDefined } } /** * Table cells merge options */ export declare class TableCellMergeOptions { /** * Row index of the first cell */ firstRowIndex: number; /** * First cell index in the row */ firstCellIndex: number; /** * Row index of the last cell */ lastRowIndex: number; /** * Last cell index in the row */ lastCellIndex: number; /** * Allow splitting */ allowSplitting?: boolean; } /** * Table cell split type */ /** * Table cell split type */ export declare enum TableCellSplitType { 'SplitByWidth', 'SplitByHeight', 'SplitByColSpan', 'SplitByRowSpan' } /** * Table column. */ export declare class TableColumn { /** * Width. */ width: number; } /** * Table Row. */ export declare class TableRow { /** * Cells for the row. */ cells?: Array; /** * Minimal height of the row. */ minimalHeight?: number; /** * Height of the row. */ height?: number; } /** * Represents text bounds within a paragraph or portion. */ export declare class TextBounds { /** * X coordinate of the text bounds. */ x: number; /** * X coordinate of the text bounds. */ y: number; /** * Width of the text bounds. */ width: number; /** * Height of the text bounds. */ height: number; } /** * Mathematical text */ export declare class TextElement extends MathElement { constructor(); /** * Value */ value?: string; } export declare namespace TextElement { } /** * Contains the TextFrame's formatting properties. */ export declare class TextFrameFormat { /** * Represents 3d effect properties for a text. */ threeDFormat?: ThreeDFormat; /** * Gets or sets text wrapping shape. */ transform?: TextFrameFormat.TransformEnum; /** * Left margin. Left margin. */ marginLeft?: number; /** * Right margin. */ marginRight?: number; /** * Top margin. */ marginTop?: number; /** * Bottom margin. */ marginBottom?: number; /** * True if text is wrapped at TextFrame's margins. */ wrapText?: TextFrameFormat.WrapTextEnum; /** * Returns or sets vertical anchor text in a TextFrame. */ anchoringType?: TextFrameFormat.AnchoringTypeEnum; /** * If True then text should be centered in box horizontally. */ centerText?: TextFrameFormat.CenterTextEnum; /** * Determines text orientation. The resulted value of visual text rotation summarized from this property and custom angle in property RotationAngle. */ textVerticalType?: TextFrameFormat.TextVerticalTypeEnum; /** * Returns or sets text's auto-fit mode. */ autofitType?: TextFrameFormat.AutofitTypeEnum; /** * Returns or sets number of columns in the text area. This value must be a positive number. Otherwise, the value will be set to zero. Value 0 means undefined value. */ columnCount?: number; /** * Returns or sets the space between text columns in the text area (in points). This should only apply when there is more than 1 column present. This value must be a positive number. Otherwise, the value will be set to zero. */ columnSpacing?: number; /** * Returns or set keeping text out of 3D scene entirely. */ keepTextFlat?: boolean; /** * Specifies the custom rotation that is being applied to the text within the bounding box. */ rotationAngle?: number; /** * Default portion format. */ defaultParagraphFormat?: ParagraphFormat; } export declare namespace TextFrameFormat { enum TransformEnum { None, Plain, Stop, Triangle, TriangleInverted, Chevron, ChevronInverted, RingInside, RingOutside, ArchUp, ArchDown, Circle, Button, ArchUpPour, ArchDownPour, CirclePour, ButtonPour, CurveUp, CurveDown, CanUp, CanDown, Wave1, Wave2, DoubleWave1, Wave4, Inflate, Deflate, InflateBottom, DeflateBottom, InflateTop, DeflateTop, DeflateInflate, DeflateInflateDeflate, FadeRight, FadeLeft, FadeUp, FadeDown, SlantUp, SlantDown, CascadeUp, CascadeDown, Custom, NotDefined } enum WrapTextEnum { False, True, NotDefined } enum AnchoringTypeEnum { Top, Center, Bottom, Justified, Distributed, NotDefined } enum CenterTextEnum { False, True, NotDefined } enum TextVerticalTypeEnum { Horizontal, Vertical, Vertical270, WordArtVertical, EastAsianVertical, MongolianVertical, WordArtVerticalRightToLeft, NotDefined } enum AutofitTypeEnum { None, Normal, Shape, NotDefined } } /** * Represents text item, referenced by TextItems */ export declare class TextItem { /** * Gets or sets the URI to resource that contains text */ uri?: ResourceUri; /** * Gets or sets the text. */ text?: string; } /** * Represents text of resource */ export declare class TextItems extends ResourceBase { constructor(); /** * Gets or sets the text items. */ items?: Array; } /** * Represents Slide's theme */ export declare class Theme extends ResourceBase { constructor(); /** * Name. */ name?: string; /** * Color scheme. */ colorScheme?: ResourceUri; /** * Font scheme. */ fontScheme?: ResourceUri; /** * Format scheme. */ formatScheme?: ResourceUri; } /** * ThreeDFormat */ export declare class ThreeDFormat { /** * Type of a bottom 3D bevel. */ bevelBottom?: ShapeBevel; /** * Type of a top 3D bevel. */ bevelTop?: ShapeBevel; /** * Camera */ camera?: Camera; /** * Contour color */ contourColor?: string; /** * Contour width */ contourWidth?: number; /** * Depth */ depth?: number; /** * Extrusion color */ extrusionColor?: string; /** * Extrusion height */ extrusionHeight?: number; /** * Light rig */ lightRig?: LightRig; /** * Material */ material?: ThreeDFormat.MaterialEnum; } export declare namespace ThreeDFormat { enum MaterialEnum { Clear, DkEdge, Flat, LegacyMatte, LegacyMetal, LegacyPlastic, LegacyWireframe, Matte, Metal, Plastic, Powder, SoftEdge, Softmetal, TranslucentPowder, WarmMatte, NotDefined } } /** * Provides options that control how a presentation is saved in TIFF format. */ export declare class TiffExportOptions extends ImageExportOptionsBase { constructor(); /** * Compression type. */ compression?: TiffExportOptions.CompressionEnum; /** * Horizontal resolution, in dots per inch. */ dpiX?: number; /** * Vertical resolution, in dots per inch. */ dpiY?: number; /** * Specifies whether the generated document should include hidden slides or not. Default is false. */ showHiddenSlides?: boolean; /** * Specifies the pixel format for the generated images. Read/write ImagePixelFormat. */ pixelFormat?: TiffExportOptions.PixelFormatEnum; /** * Slides layouting options */ slidesLayoutOptions?: SlidesLayoutOptions; /** * Specifies the algorithm for converting a color image into a black and white image. This option will applied only if Aspose.Slides.Export.TiffOptions.CompressionType is set to Aspose.Slides.Export.TiffCompressionTypes.CCITT4 or Aspose.Slides.Export.TiffCompressionTypes.CCITT3. */ bwConversionMode?: TiffExportOptions.BwConversionModeEnum; } export declare namespace TiffExportOptions { enum CompressionEnum { Default, None, CCITT3, CCITT4, LZW, RLE } enum PixelFormatEnum { Format1bppIndexed, Format4bppIndexed, Format8bppIndexed, Format24bppRgb, Format32bppArgb } enum BwConversionModeEnum { Default, Dithering, DitheringFloydSteinberg, Auto, AutoOtsu, Threshold25, Threshold50, Threshold75 } } /** * Represents a Tint effect. */ export declare class TintEffect extends ImageTransformEffect { constructor(); /** * Hue */ hue: number; /** * Amount */ amount: number; } export declare namespace TintEffect { } /** * Update background task. */ export declare class UpdateBackground extends Task { constructor(); /** * List of slide indices. */ slides?: Array; /** * Background DTO. */ background?: SlideBackground; } export declare namespace UpdateBackground { } /** * Update shape task. */ export declare class UpdateShape extends Task { constructor(); /** * Shape DTO. */ shape?: ShapeBase; /** * Shape path for a grouped or SmartArt shape. */ shapePath?: string; } export declare namespace UpdateShape { } /** * Represents VBA module. */ export declare class VbaModule extends ResourceBase { constructor(); /** * VBA module name. */ name?: string; /** * VBA module source code. */ sourceCode?: string; /** * List of references. */ references?: Array; } /** * VBA project */ export declare class VbaProject extends ResourceBase { constructor(); /** * VBA modules */ modules?: Array; /** * VBA references */ references?: Array; } /** * VBA reference */ export declare class VbaReference { /** * Name */ name?: string; /** * Library ID */ libId?: string; } /** * Provides options that control how a presentation is saved in an video format. */ export declare class VideoExportOptions extends ExportOptions { constructor(); /** * Slides transition duration. */ slidesTransitionDuration?: number; /** * Video transition type */ transitionType?: VideoExportOptions.TransitionTypeEnum; /** * Duration of transition defined in TransitionType property. */ transitionDuration?: number; /** * Video resolution type */ videoResolutionType?: VideoExportOptions.VideoResolutionTypeEnum; } export declare namespace VideoExportOptions { enum TransitionTypeEnum { None, Fade, Distance, Slidedown, Slideright, Slideleft, Slideup, Smoothleft, Smoothright, Smoothup, Smoothdown, Rectcrop, Circlecrop, Circleclose, Circleopen, Horzclose, Horzopen, Vertclose, Vertopen, Diagbl, Diagbr, Diagtl, Diagtr, Hlslice, Hrslice, Vuslice, Vdslice, Dissolve, Pixelize, Radial } enum VideoResolutionTypeEnum { FullHD, SD, HD, QHD } } /** * Represents VideoFrame resource. */ export declare class VideoFrame extends GeometryShape { constructor(); /** * Determines whether a video is shown in full screen mode. */ fullScreenMode?: boolean; /** * Determines whether a VideoFrame is hidden. */ hideAtShowing?: boolean; /** * Determines whether a video is looped. */ playLoopMode?: boolean; /** * Returns or sets the video play mode. */ playMode?: VideoFrame.PlayModeEnum; /** * Determines whether a video is automatically rewinded to start as soon as the movie has finished playing */ rewindVideo?: boolean; /** * Returns or sets the audio volume. */ volume?: VideoFrame.VolumeEnum; /** * Video data encoded in base64. */ base64Data?: string; /** * Picture fill format. */ pictureFillFormat?: PictureFill; /** * Trim start [ms] */ trimFromStart?: number; /** * Trim end [ms] */ trimFromEnd?: number; } export declare namespace VideoFrame { enum PlayModeEnum { Auto, OnClick, AllSlides, InClickSequence, Mixed } enum VolumeEnum { Mute, Low, Medium, Loud, Mixed } } /** * Slides document properties. */ export declare class ViewProperties extends ResourceBase { constructor(); /** * Last used view mode. */ lastView?: ViewProperties.LastViewEnum; /** * Horizontal bar state. */ horizontalBarState?: ViewProperties.HorizontalBarStateEnum; /** * Vertical bar state. */ verticalBarState?: ViewProperties.VerticalBarStateEnum; /** * True to prefer single view. */ preferSingleView?: boolean; /** * The sizing of the side content region of the normal view, when the region is of a variable restored size. */ restoredLeft?: NormalViewRestoredProperties; /** * The sizing of the top slide region of the normal view, when the region is of a variable restored size. */ restoredTop?: NormalViewRestoredProperties; /** * Slide view mode properties. */ slideViewProperties?: CommonSlideViewProperties; /** * Notes view mode properties. */ notesViewProperties?: CommonSlideViewProperties; /** * True if the comments should be shown. */ showComments?: ViewProperties.ShowCommentsEnum; /** * The grid spacing that should be used for the grid underlying the presentation document, in points. */ gridSpacing?: number; } export declare namespace ViewProperties { enum LastViewEnum { NotDefined, SlideView, SlideMasterView, NotesView, HandoutView, NotesMasterView, OutlineView, SlideSorterView, SlideThumbnailView } enum HorizontalBarStateEnum { Minimized, Restored, Maximized } enum VerticalBarStateEnum { Minimized, Restored, Maximized } enum ShowCommentsEnum { False, True, NotDefined } } /** * Represents Excel spreadsheet data source. */ export declare class Workbook extends DataSource { constructor(); /** * Worksheet index. */ worksheetIndex: number; /** * Column index of the first value. */ columnIndex: number; /** * Row index of the first value. */ rowIndex: number; } export declare namespace Workbook { } /** * Provides options that control how a presentation is saved in XAML format. */ export declare class XamlExportOptions extends ExportOptions { constructor(); /** * Export hidden slides */ exportHiddenSlides?: boolean; } export declare namespace XamlExportOptions { } /** * Provides options that control how a presentation is saved in XPS format. */ export declare class XpsExportOptions extends ExportOptions { constructor(); /** * Specifies whether the generated document should include hidden slides or not. Default is false. */ showHiddenSlides?: boolean; /** * True to convert all metafiles used in a presentation to the PNG images. */ saveMetafilesAsPng?: boolean; /** * True to draw black frame around each slide. */ drawSlidesFrame?: boolean; } export declare namespace XpsExportOptions { } /** * Zoom frame. */ export declare class ZoomFrame extends ZoomObject { constructor(); /** * Links to the target slide */ targetSlideIndex?: number; } export declare namespace ZoomFrame { }