@univerjs-pro/engine-shape 1.0.0-beta.0 → 1.0.0-beta.1

package/lib/types/shape-type.d.ts

@@ -1,6 +1,7 @@
 import type { IFormulaLastValue } from '@univerjs-pro/engine-formula';
 import type { HorizontalAlign, IDocumentData, IGlowEffect, IShadowEffect, VerticalAlign } from '@univerjs/core';
-import type { BasicShapeEnum, ImageFillModeEnum, ImageSourceTypeEnum, ShapeArrowSizeEnum, ShapeArrowTypeEnum, ShapeFillEnum, ShapeGradientTypeEnum, ShapeLineCapEnum, ShapeLineDashEnum, ShapeLineJoinEnum, ShapeLineTypeEnum, ShapeOperatorEnum, ShapeRenderModeEnum, ShapeSketchTypeEnum, ShapeTypeEnum } from './shape-enum';
+import type { BasicShapeEnum, ImageFillModeEnum, ImageSourceTypeEnum, ShapeArrowSizeEnum, ShapeArrowTypeEnum, ShapeBevelPresetEnum, ShapeCameraPresetEnum, ShapeFillEnum, ShapeGradientTypeEnum, ShapeLightRigDirectionEnum, ShapeLightRigPresetEnum, ShapeLineCapEnum, ShapeLineDashEnum, ShapeLineJoinEnum, ShapeLineTypeEnum, ShapeMaterialPresetEnum, ShapeOperatorEnum, ShapeRenderModeEnum, ShapeSketchTypeEnum, ShapeTypeEnum } from './shape-enum';
+import type { SmartArtCategoryEnum, SmartArtDefinitionScopeEnum, SmartArtDirectionEnum, SmartArtNodeRoleEnum, SmartArtPresentationShapeRoleEnum, SmartArtPresentationTextSourceEnum, SmartArtTextFontSizeModeEnum, SmartArtTopologyPointKindEnum } from './smart-art/smart-art-enum';
 /**
  * GdContext 用来计算 OOXML Shape 的 Geometry Definitions (gd)
  * 包含：
@@ -640,6 +641,10 @@ export interface IShapeTextBodyBehavior {
      * OOXML normAutofit lnSpcReduction.
      */
     lineSpaceReduction?: number;
+    /** DrawingML text-body camera and lighting (`a:bodyPr/a:scene3d`). */
+    scene3d?: IShapeScene3D;
+    /** DrawingML text-glyph bevel, extrusion, contour, and material (`a:bodyPr/a:sp3d`). */
+    shape3d?: IShape3D;
 }
 export interface IShapeText extends IShapeTextAlign, IShapeTextBodyBehavior {
     isRichText: false;
@@ -686,6 +691,207 @@ export interface IShapeFormulaBinding {
     /** Last successful scalar value persisted with the Shape for stale-first reload rendering. */
     lastValue?: IFormulaLastValue;
 }
+/** Rotation in degrees corresponding to DrawingML `<a:rot lat="..." lon="..." rev="...">`. */
+export interface IShape3DRotation {
+    latitude?: number;
+    longitude?: number;
+    revolution?: number;
+}
+/** Normalized 2.5D projection resolved from a built-in camera or SmartArt style. */
+export interface IShape3DCameraProjection {
+    rotation?: IShape3DRotation;
+    verticalOffsetRatio?: number;
+    verticalScale?: number;
+}
+/** A point/vector in the DrawingML 3D scene coordinate system. */
+export interface IShape3DVector {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Shape scene corresponding to DrawingML `<a:scene3d>`. */
+export interface IShapeScene3D {
+    camera: {
+        preset: ShapeCameraPresetEnum;
+        fieldOfView?: number;
+        zoom?: number;
+        rotation?: IShape3DRotation;
+        /** Rendering semantics kept separate from the original DrawingML camera values. */
+        projection?: IShape3DCameraProjection;
+    };
+    lightRig: {
+        preset: ShapeLightRigPresetEnum;
+        direction: ShapeLightRigDirectionEnum;
+        rotation?: IShape3DRotation;
+    };
+    backdrop?: {
+        anchor: IShape3DVector;
+        normal: IShape3DVector;
+        upVector: IShape3DVector;
+    };
+}
+/** Bevel corresponding to DrawingML `<a:bevelT>` or `<a:bevelB>`. */
+export interface IShapeBevel3D {
+    width?: number;
+    height?: number;
+    preset?: ShapeBevelPresetEnum;
+}
+/** Shape depth/material corresponding to DrawingML `<a:sp3d>`. */
+export interface IShape3D {
+    z?: number;
+    extrusionHeight?: number;
+    contourWidth?: number;
+    material?: ShapeMaterialPresetEnum;
+    topBevel?: IShapeBevel3D;
+    bottomBevel?: IShapeBevel3D;
+    extrusionColor?: string;
+    contourColor?: string;
+}
+/** Reflection corresponding to DrawingML `<a:reflection>`. */
+export interface IShapeReflectionEffect {
+    /** Blur radius in drawing points. */
+    blurRadius?: number;
+    /** Opacity at the reflection edge nearest the source, from 0 to 1. */
+    startAlpha?: number;
+    /** Opacity at the far edge of the reflection, from 0 to 1. */
+    endAlpha?: number;
+    /** Distance between the source and its reflection. */
+    distance?: number;
+    /** Reflection direction in degrees. */
+    direction?: number;
+    /** Vertical reflection scale; 1 means 100%. */
+    scaleY?: number;
+}
+/** Soft edge corresponding to DrawingML `<a:softEdge>`. */
+export interface IShapeSoftEdgeEffect {
+    radius: number;
+}
+export interface ISmartArtTransform {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    flipX?: boolean;
+    flipY?: boolean;
+}
+/** Logical content node edited through the SmartArt Text Pane. */
+export interface ISmartArtDataNode {
+    id: string;
+    parentId?: string;
+    childIds: string[];
+    role: SmartArtNodeRoleEnum;
+    text: IShapeTextData;
+    /** Automatic nodes participate in their layout font-size group; manual nodes keep explicit user sizing. */
+    fontSizeMode?: SmartArtTextFontSizeModeEnum;
+}
+/** Maps one rendered SmartArt text paragraph to its logical Text Pane node. */
+export interface ISmartArtPresentationTextBinding {
+    dataNodeId: string;
+    paragraphIndex: number;
+}
+/** One independently selectable ordinary Shape inside the SmartArt composite. */
+export interface ISmartArtPresentationShape {
+    id: string;
+    name?: string;
+    role: SmartArtPresentationShapeRoleEnum;
+    dataNodeIds: string[];
+    transform: ISmartArtTransform;
+    shapeData: IBasicShapeData;
+    textSource?: SmartArtPresentationTextSourceEnum;
+    textBindings?: ISmartArtPresentationTextBinding[];
+    sourcePresentationShapeId?: string;
+    targetPresentationShapeId?: string;
+}
+/** Layout graph point retained as normalized SmartArt semantics, including non-content transition points. */
+export interface ISmartArtTopologyPoint {
+    id: string;
+    kind: SmartArtTopologyPointKindEnum;
+    connectionId?: string;
+    properties: Record<string, string>;
+    layoutVariableOrder: string[];
+    layoutVariables: Record<string, Record<string, string>>;
+    propertyProgram?: ISmartArtDefinitionInstruction;
+}
+/** Directed relation in the complete layout graph. An omitted kind is a logical parent-child relation. */
+export interface ISmartArtTopologyConnection {
+    id: string;
+    kind?: string;
+    sourceId: string;
+    destinationId: string;
+    sourceOrder: number;
+    destinationOrder: number;
+    presentationId?: string;
+}
+/**
+ * Complete semantic layout graph used by layout engines and exchange adapters.
+ * It is intentionally independent from XML nodes and includes transition/presentation points hidden by the Text Pane.
+ */
+export interface ISmartArtTopology {
+    pointOrder: string[];
+    points: Record<string, ISmartArtTopologyPoint>;
+    connectionOrder: string[];
+    connections: Record<string, ISmartArtTopologyConnection>;
+}
+export interface ISmartArtDefinitionParameter {
+    name: string;
+    scope?: SmartArtDefinitionScopeEnum;
+    value: string;
+}
+/** Namespace-neutral instruction in a SmartArt layout, quick-style, or color program. */
+export interface ISmartArtDefinitionInstruction {
+    operation: string;
+    scope: SmartArtDefinitionScopeEnum;
+    parameters: ISmartArtDefinitionParameter[];
+    text?: string;
+    children: ISmartArtDefinitionInstruction[];
+}
+/** Univer semantic programs used both by the layout engine and OOXML adapters. */
+export interface ISmartArtDefinitions {
+    layout?: ISmartArtDefinitionInstruction;
+    quickStyle?: ISmartArtDefinitionInstruction;
+    colorStyle?: ISmartArtDefinitionInstruction;
+}
+/** Structural edit limits normalized from the SmartArt layout definition (for example `chMax` and assistant branches). */
+export interface ISmartArtEditCapabilities {
+    /** One-based depth. Omit when the layout accepts an arbitrary number of hierarchy levels. */
+    maxDepth?: number;
+    supportsAddAfter?: boolean;
+    supportsAssistant: boolean;
+}
+/** Univer's normalized SmartArt model. OOXML parts are mapped to and from this structure by exchange adapters. */
+export interface ISmartArtData {
+    version: 1;
+    /** Stable layout coordinate space used to scale presentation Shapes with the outer SmartArt frame. */
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    layout: {
+        id: string;
+        category: SmartArtCategoryEnum;
+        editCapabilities?: ISmartArtEditCapabilities;
+    };
+    style: {
+        quickStyleId?: string;
+        colorStyleId?: string;
+    };
+    direction: SmartArtDirectionEnum;
+    rootNodeIds: string[];
+    nodes: Record<string, ISmartArtDataNode>;
+    presentationShapeOrder: string[];
+    presentationShapes: Record<string, ISmartArtPresentationShape>;
+    topology?: ISmartArtTopology;
+    definitions?: ISmartArtDefinitions;
+    /** Imported data-model program retained for lossless OOXML round trips and GUID-stable text edits. */
+    dataProgram?: ISmartArtDefinitionInstruction;
+    /** The logical node text changed and must be synchronized into dataProgram during export. */
+    dataProgramTextDirty?: boolean;
+    /** The logical node tree changed and must be synchronized into dataProgram during export. */
+    dataProgramStructureDirty?: boolean;
+    /** Compiled presentation cache. Structural or presentation-Shape edits must invalidate it. */
+    presentationProgram?: ISmartArtDefinitionInstruction;
+}
 /**
  * This interface defines the shape data structure , and this part will save in json
  */
@@ -758,6 +964,14 @@ export interface IBasicShapeData {
     outerShadow?: IShadowEffect;
     /** Glow applied around the rendered shape path. */
     glow?: IGlowEffect;
+    /** Mirrored copy rendered behind the shape. */
+    reflection?: IShapeReflectionEffect;
+    /** Alpha-edge feathering radius. */
+    softEdge?: IShapeSoftEdgeEffect;
+    /** DrawingML scene camera, lighting, and backdrop (`a:scene3d`). */
+    scene3d?: IShapeScene3D;
+    /** DrawingML extrusion, bevel, contour, and material (`a:sp3d`). */
+    shape3d?: IShape3D;
     shapeText?: IShapeTextData;
     /**
      * Text box inset used to calculate the editable/rendered text rect.
@@ -767,6 +981,11 @@ export interface IBasicShapeData {
     /** Presence of this field identifies a formula shape. */
     formulaBinding?: IShapeFormulaBinding;
 }
+/** SmartArt persists as one composite Shape while its presentation Shapes remain independently editable subentities. */
+export interface ISmartArtShapeData extends IBasicShapeData {
+    shapeType: ShapeTypeEnum.SmartArt;
+    smartArt: ISmartArtData;
+}
 export interface ICxnShapeData extends IBasicShapeData {
     points?: Array<{
         x: number;
@@ -788,7 +1007,7 @@ export interface IGroupShapeData {
     childShapeIds: string[];
     shapeData?: Record<string, IShapeData>;
 }
-export type IShapeData = IBasicShapeData | ICxnShapeData;
+export type IShapeData = IBasicShapeData | ICxnShapeData | ISmartArtShapeData;
 export interface IShapeJSONData {
     id: string;
     name?: string;
@@ -926,6 +1145,10 @@ export interface IShapeRenderParameters {
     angle?: number;
     oKey: string;
     image?: HTMLImageElement;
+    /** Loaded picture fills keyed by SmartArt presentation Shape id. */
+    smartArtImages?: ReadonlyMap<string, HTMLImageElement>;
+    /** SmartArt owns one shared camera; child shapes keep scene lighting without re-projecting themselves. */
+    skipShape3DCameraTransform?: boolean;
 }
 export interface IShapeRelationItem {
     shapeId: string;

package/lib/types/smart-art/smart-art-color-style.d.ts

@@ -0,0 +1,11 @@
+import type { ISmartArtData } from '../shape-type';
+export type SmartArtColorStyleSection = 'theme' | 'colorful' | 'accent1' | 'accent2' | 'accent3' | 'accent4' | 'accent5' | 'accent6';
+export interface ISmartArtColorStyleCatalogItem {
+    id: string;
+    key: string;
+    section: SmartArtColorStyleSection;
+    colors: readonly string[];
+    variant: 'outline' | 'fill' | 'gradient' | 'cycle' | 'transparent';
+}
+export declare const SMART_ART_COLOR_STYLE_CATALOG: readonly ISmartArtColorStyleCatalogItem[];
+export declare function applySmartArtColorStyle(data: ISmartArtData, colorStyleId: string): ISmartArtData;

package/lib/types/smart-art/smart-art-enum.d.ts

@@ -0,0 +1,59 @@
+export declare enum SmartArtCategoryEnum {
+    All = "all",
+    List = "list",
+    Process = "process",
+    Cycle = "cycle",
+    Hierarchy = "hierarchy",
+    Relationship = "relationship",
+    Matrix = "matrix",
+    Pyramid = "pyramid",
+    Picture = "picture",
+    Timeline = "timeline",
+    Team = "team",
+    TextCard = "textCard"
+}
+export declare enum SmartArtDirectionEnum {
+    LeftToRight = "leftToRight",
+    RightToLeft = "rightToLeft"
+}
+export declare enum SmartArtNodeRoleEnum {
+    Content = "content",
+    Assistant = "assistant"
+}
+export declare enum SmartArtTextFontSizeModeEnum {
+    Auto = "auto",
+    Manual = "manual"
+}
+export declare enum SmartArtPresentationShapeRoleEnum {
+    Node = "node",
+    Connector = "connector",
+    Background = "background",
+    Decoration = "decoration",
+    Image = "image",
+    Text = "text"
+}
+export declare enum SmartArtPresentationTextSourceEnum {
+    DataNode = "dataNode",
+    Presentation = "presentation"
+}
+export declare enum SmartArtTopologyPointKindEnum {
+    Document = "document",
+    Content = "content",
+    Assistant = "assistant",
+    ParentTransition = "parentTransition",
+    SiblingTransition = "siblingTransition",
+    Presentation = "presentation"
+}
+export declare enum SmartArtDefinitionScopeEnum {
+    Diagram = "diagram",
+    DiagramDrawing = "diagramDrawing",
+    Drawing = "drawing",
+    Relationships = "relationships"
+}
+export declare enum SmartArtInsertPositionEnum {
+    Before = "before",
+    After = "after",
+    Above = "above",
+    Below = "below",
+    Assistant = "assistant"
+}

package/lib/types/smart-art/smart-art-layout-template.d.ts

@@ -0,0 +1,32 @@
+import type { ShapeTypeEnum } from '../shape-enum';
+import type { IBasicShapeData, IShapeTextData, ISmartArtData, ISmartArtTransform } from '../shape-type';
+import type { SmartArtCategoryEnum, SmartArtNodeRoleEnum, SmartArtPresentationShapeRoleEnum } from './smart-art-enum';
+import { SmartArtDirectionEnum, SmartArtPresentationTextSourceEnum } from './smart-art-enum';
+export interface ISmartArtLayoutTemplate {
+    layout: {
+        id: string;
+        category: SmartArtCategoryEnum;
+    };
+    direction: SmartArtDirectionEnum;
+    supportsAddAfter?: boolean;
+    nodes: Array<{
+        parentIndex: number;
+        role: SmartArtNodeRoleEnum;
+    }>;
+    presentationShapes: Array<{
+        role: SmartArtPresentationShapeRoleEnum;
+        nodeIndexes: number[];
+        textNodeIndexes?: number[];
+        transform: ISmartArtTransform;
+        shapeType: ShapeTypeEnum;
+        shapeData?: IBasicShapeData;
+        shapeText?: IShapeTextData;
+        textSource?: SmartArtPresentationTextSourceEnum;
+    }>;
+    variants?: Array<Pick<ISmartArtLayoutTemplate, 'nodes' | 'presentationShapes'>>;
+}
+export declare function createSmartArtDataFromLayout(layoutId: string): ISmartArtData | null;
+export declare function applySmartArtLayout(data: ISmartArtData, layoutId: string, options?: {
+    preservePresentationStyles?: boolean;
+}): ISmartArtData;
+export declare function reflowSmartArtDataToMatchingTemplate(data: ISmartArtData): ISmartArtData;

package/lib/types/smart-art/smart-art-layout-templates.generated.d.ts

@@ -0,0 +1,2 @@
+import type { ISmartArtLayoutTemplate } from './smart-art-layout-template';
+export declare const SMART_ART_LAYOUT_TEMPLATES: Readonly<Record<string, ISmartArtLayoutTemplate>>;

package/lib/types/smart-art/smart-art-model.d.ts

@@ -0,0 +1,46 @@
+import type { IBasicShapeData, IShapeData, IShapeTextData, ISmartArtData, ISmartArtDataNode, ISmartArtPresentationShape, ISmartArtPresentationTextBinding, ISmartArtShapeData } from '../shape-type';
+import type { SmartArtCategoryEnum, SmartArtDirectionEnum } from './smart-art-enum';
+import { SmartArtInsertPositionEnum, SmartArtPresentationShapeRoleEnum, SmartArtTextFontSizeModeEnum } from './smart-art-enum';
+export interface IInsertSmartArtNodeOptions {
+    node: ISmartArtDataNode;
+    targetNodeId?: string;
+    position: SmartArtInsertPositionEnum;
+}
+export interface IMoveSmartArtNodeOptions {
+    nodeId: string;
+    targetNodeId: string;
+    position: Exclude<SmartArtInsertPositionEnum, SmartArtInsertPositionEnum.Assistant>;
+}
+export interface IUpdateSmartArtPresentationTextOptions {
+    fontSizeMode?: SmartArtTextFontSizeModeEnum;
+    fontSizeNodeId?: string;
+}
+export interface IConvertedSmartArtShape {
+    id: string;
+    transform: ISmartArtPresentationShape['transform'];
+    shapeData: ISmartArtPresentationShape['shapeData'];
+}
+export declare function isSmartArtShapeData(shapeData: IShapeData): shapeData is ISmartArtShapeData;
+export declare function insertSmartArtNode(data: ISmartArtData, options: IInsertSmartArtNodeOptions): ISmartArtData;
+export declare function deleteSmartArtNode(data: ISmartArtData, nodeId: string): ISmartArtData;
+export declare function moveSmartArtNode(data: ISmartArtData, options: IMoveSmartArtNodeOptions): ISmartArtData;
+export declare function promoteSmartArtNode(data: ISmartArtData, nodeId: string): ISmartArtData;
+export declare function demoteSmartArtNode(data: ISmartArtData, nodeId: string): ISmartArtData;
+export declare function updateSmartArtNode(data: ISmartArtData, nodeId: string, update: Partial<Pick<ISmartArtDataNode, 'fontSizeMode' | 'role' | 'text'>>): ISmartArtData;
+export declare function readSmartArtTextContent(text: IShapeTextData): string;
+export declare function resolveSmartArtPresentationTextBindings(data: ISmartArtData, presentationShapeId: string): ISmartArtPresentationTextBinding[];
+export declare function resolveSmartArtPresentationShapeIdForNode(data: ISmartArtData, nodeId: string, preferredRole?: SmartArtPresentationShapeRoleEnum): string | undefined;
+/** Resolves a character offset in a rendered presentation text Shape back to its logical Text Pane node. */
+export declare function resolveSmartArtPresentationNodeIdAtTextOffset(data: ISmartArtData, presentationShapeId: string, textOffset: number): string | undefined;
+export declare function updateSmartArtPresentationText(data: ISmartArtData, presentationShapeId: string, shapeText: IShapeTextData, options?: IUpdateSmartArtPresentationTextOptions): ISmartArtData;
+export declare function resetSmartArtTextFontSizes(data: ISmartArtData): ISmartArtData;
+export declare function replaceSmartArtTextContent(previous: IShapeTextData, nextText: string, documentId?: string): IShapeTextData;
+export declare function setSmartArtDirection(data: ISmartArtData, direction: SmartArtDirectionEnum): ISmartArtData;
+export declare function setSmartArtLayout(data: ISmartArtData, layout: {
+    id: string;
+    category: SmartArtCategoryEnum;
+}): ISmartArtData;
+export declare function updateSmartArtPresentationShape(data: ISmartArtData, presentationShapeId: string, update: Partial<Pick<ISmartArtPresentationShape, 'shapeData' | 'transform'>>): ISmartArtData;
+export declare function resolveSmartArtPresentationShapeData(data: ISmartArtData, presentationShapeId: string, textScale?: number): IBasicShapeData | null;
+export declare function convertSmartArtToShapes(data: ISmartArtData): IConvertedSmartArtShape[];
+export declare function validateSmartArtData(data: ISmartArtData): string[];

package/lib/types/smart-art/smart-art-operation.d.ts

@@ -0,0 +1,83 @@
+import type { IShapeTextData, ISmartArtData, ISmartArtDataNode, ISmartArtPresentationShape } from '../shape-type';
+import type { SmartArtDirectionEnum } from './smart-art-enum';
+import { SmartArtInsertPositionEnum } from './smart-art-enum';
+export declare enum SmartArtOperationTypeEnum {
+    Replace = "replace",
+    InsertNode = "insertNode",
+    DeleteNode = "deleteNode",
+    MoveNode = "moveNode",
+    PromoteNode = "promoteNode",
+    DemoteNode = "demoteNode",
+    UpdateNode = "updateNode",
+    UpdateNodeText = "updateNodeText",
+    UpdatePresentationShape = "updatePresentationShape",
+    UpdatePresentationText = "updatePresentationText",
+    ReplacePresentationImage = "replacePresentationImage",
+    SetDirection = "setDirection",
+    SetLayout = "setLayout",
+    SetQuickStyle = "setQuickStyle",
+    SetColorStyle = "setColorStyle",
+    Reset = "reset"
+}
+export type SmartArtOperation = {
+    type: SmartArtOperationTypeEnum.Replace;
+    data: ISmartArtData;
+} | {
+    type: SmartArtOperationTypeEnum.InsertNode;
+    nodeId: string;
+    node?: ISmartArtDataNode;
+    targetNodeId?: string;
+    position: SmartArtInsertPositionEnum;
+} | {
+    type: SmartArtOperationTypeEnum.DeleteNode;
+    nodeId: string;
+} | {
+    type: SmartArtOperationTypeEnum.MoveNode;
+    nodeId: string;
+    targetNodeId: string;
+    position: Exclude<SmartArtInsertPositionEnum, SmartArtInsertPositionEnum.Assistant>;
+} | {
+    type: SmartArtOperationTypeEnum.PromoteNode;
+    nodeId: string;
+} | {
+    type: SmartArtOperationTypeEnum.DemoteNode;
+    nodeId: string;
+} | {
+    type: SmartArtOperationTypeEnum.UpdateNode;
+    nodeId: string;
+    update: Partial<Pick<ISmartArtDataNode, 'fontSizeMode' | 'role' | 'text'>>;
+} | {
+    type: SmartArtOperationTypeEnum.UpdateNodeText;
+    nodeId: string;
+    text: string;
+} | {
+    type: SmartArtOperationTypeEnum.UpdatePresentationShape;
+    presentationShapeId: string;
+    update: Partial<Pick<ISmartArtPresentationShape, 'shapeData' | 'transform'>>;
+} | {
+    type: SmartArtOperationTypeEnum.UpdatePresentationText;
+    presentationShapeId: string;
+    shapeText: IShapeTextData;
+    fontSizeChanged?: boolean;
+    fontSizeNodeId?: string;
+} | {
+    type: SmartArtOperationTypeEnum.ReplacePresentationImage;
+    presentationShapeId: string;
+    source: string;
+    sourceType: NonNullable<ISmartArtPresentationShape['shapeData']['fill']>['fillImageSourceType'];
+} | {
+    type: SmartArtOperationTypeEnum.SetDirection;
+    direction: SmartArtDirectionEnum;
+} | {
+    type: SmartArtOperationTypeEnum.SetLayout;
+    layoutId: string;
+} | {
+    type: SmartArtOperationTypeEnum.SetQuickStyle;
+    quickStyleId: string;
+} | {
+    type: SmartArtOperationTypeEnum.SetColorStyle;
+    colorStyleId: string;
+} | {
+    type: SmartArtOperationTypeEnum.Reset;
+};
+export declare function applySmartArtOperation(data: ISmartArtData, operation: SmartArtOperation): ISmartArtData;

package/lib/types/smart-art/smart-art-quick-style.d.ts

@@ -0,0 +1,12 @@
+import type { IBasicShapeData, ISmartArtData } from '../shape-type';
+import { SmartArtPresentationShapeRoleEnum } from './smart-art-enum';
+export type SmartArtQuickStyleSection = 'bestMatch' | 'threeDimensional';
+export interface ISmartArtQuickStyleCatalogItem {
+    id: string;
+    key: string;
+    section: SmartArtQuickStyleSection;
+    preview: 'flat' | 'outline' | 'subtle' | 'moderate' | 'intense' | 'bevel' | 'inset' | 'cartoon' | 'powder' | 'brick' | 'flatScene' | 'metal' | 'sunset' | 'birdEye';
+}
+export declare const SMART_ART_QUICK_STYLE_CATALOG: readonly ISmartArtQuickStyleCatalogItem[];
+export declare function resolveSmartArtQuickStyle3DShapeData(shapeData: IBasicShapeData, role: SmartArtPresentationShapeRoleEnum, quickStyleId?: string): IBasicShapeData;
+export declare function applySmartArtQuickStyle(data: ISmartArtData, quickStyleId: string): ISmartArtData;

package/lib/types/smart-art/smart-art-transform.d.ts

@@ -0,0 +1,2 @@
+import type { ISmartArtData, ISmartArtTransform } from '../shape-type';
+export declare function resolveSmartArtPresentationTransform(data: ISmartArtData, transform: ISmartArtTransform, hostWidth: number, hostHeight: number): ISmartArtTransform;