FEnum

const sheet = univerAPI.getActiveWorkbook()?.getActiveSheet()if (!sheet) throw new Error('No active worksheet')sheet.getRange('A1').setWrapStrategy(univerAPI.Enum.WrapStrategy.WRAP)

type EnumValues = {  IS: 'is'  IS_NOT: 'isNot'  CONTAINS: 'contains'  NOT_CONTAINS: 'notContains'  IS_EMPTY: 'isEmpty'  IS_NOT_EMPTY: 'isNotEmpty'  GREATER_THAN: 'greaterThan'  LESS_THAN: 'lessThan'  BEFORE: 'before'  AFTER: 'after'}

const base = univerAPI.getActiveBase()if (!base) throw new Error('Open a Base before running this example.')const table = base.insertTable(`Conditional operator ${Date.now()}`, {  primaryFieldName: 'Risk item',})const title = table.getPrimaryField()const view = table.getViewByName('Grid')if (!view) throw new Error('The default Grid view was not created.')view.addConditionalColorRule({  id: 'delay-risk',  color: '#fff7df',  target: univerAPI.Enum.BaseConditionalColorTarget.CELL,  fieldId: title.getId(),  operator: univerAPI.Enum.BaseConditionalColorOperator.CONTAINS,  operand: 'delay',})

type EnumValues = {  /** Paint only the cell in the rule's field. */  CELL: 'cell'  /** Paint the complete record row. */  ROW: 'row'  /** Paint the rule's field column unconditionally; operator, operand, and date mode are ignored. */  COLUMN: 'column'}

const base = univerAPI.getActiveBase()if (!base) throw new Error('Open a Base before running this example.')const table = base.insertTable(`Conditional target ${Date.now()}`, {  primaryFieldName: 'Risk item',})const level = table.addField('Risk level', univerAPI.Enum.BaseFieldType.Number)const view = table.getViewByName('Grid')if (!view) throw new Error('The default Grid view was not created.')view.addConditionalColorRule({  id: 'high-risk',  color: '#fde9e9',  target: univerAPI.Enum.BaseConditionalColorTarget.ROW,  fieldId: level.getId(),  operator: univerAPI.Enum.BaseConditionalColorOperator.GREATER_THAN,  operand: 80,})

type EnumValues = {  EXACT: 'exact'  TODAY: 'today'  TOMORROW: 'tomorrow'  YESTERDAY: 'yesterday'  THIS_WEEK: 'thisWeek'  LAST_WEEK: 'lastWeek'  THIS_MONTH: 'thisMonth'  LAST_MONTH: 'lastMonth'  PAST_7_DAYS: 'past7'  NEXT_7_DAYS: 'next7'  PAST_30_DAYS: 'past30'  NEXT_30_DAYS: 'next30'}

const base = univerAPI.getActiveBase()if (!base) throw new Error('Open a Base before running this example.')const table = base.insertTable(`Conditional date ${Date.now()}`, {  primaryFieldName: 'Risk item',})const dueDate = table.addField('Due date', univerAPI.Enum.BaseFieldType.Date)const view = table.getViewByName('Grid')if (!view) throw new Error('The default Grid view was not created.')view.addConditionalColorRule({  id: 'due-soon',  color: '#eef3ff',  target: univerAPI.Enum.BaseConditionalColorTarget.ROW,  fieldId: dueDate.getId(),  operator: univerAPI.Enum.BaseConditionalColorOperator.IS,  dateMode: univerAPI.Enum.BaseConditionalDateMode.NEXT_7_DAYS,})

type EnumValues = {  /** A built-in Base UI interaction initiated the command. */  UI: BaseEventSource.UI  /** A Facade API method initiated the command. */  Facade: BaseEventSource.Facade  /** The mutation arrived through collaboration. */  Remote: BaseEventSource.Remote  /** The local Undo stack replayed the inverse mutation. */  Undo: BaseEventSource.Undo  /** The local Redo stack replayed the mutation. */  Redo: BaseEventSource.Redo  /** An import pipeline applied a mutation carrying hierarchy metadata. */  Import: BaseEventSource.Import}

const disposable = univerAPI.addEvent(  univerAPI.Event.BaseHierarchyChanged,  ({ changes, source }) => {    if (source === univerAPI.Enum.BaseEventSource.Remote) return    for (const change of changes) {      console.log(change.recordId, change.parentRecordId, source)    }  },)// Call disposable.dispose() when the integration is torn down.

type EnumValues = {  Id: BaseFieldKeyEnum.Id  Name: BaseFieldKeyEnum.Name  Auto: BaseFieldKeyEnum.Auto}

const fBase = univerAPI.getActiveBase()const fBaseTable = fBase.getTableById('table-1')const record = fBaseTable.addRecord(  {    Title: 'Ship beta',    Status: 'todo',  },  univerAPI.Enum.BaseFieldKeyEnum.Name,)console.log(record)

type EnumValues = {  AND: BaseFilterConjunction.AND  OR: BaseFilterConjunction.OR}

const fBase = univerAPI.getActiveBase()const fBaseTable = fBase.getTableById('table-1')const view = fBaseTable.getViewByName('Grid')view.setFilter({  conjunction: univerAPI.Enum.BaseFilterConjunction.AND,  filters: [    {      fieldId: 'fld-1',      operator: univerAPI.Enum.BaseFilterOperator.Equals,      value: 'John Doe',    },  ],})

type EnumValues = {  IS: BaseFilterOperator.IS  IS_NOT: BaseFilterOperator.IS_NOT  CONTAINS: BaseFilterOperator.CONTAINS  NOT_CONTAINS: BaseFilterOperator.NOT_CONTAINS  IS_EMPTY: BaseFilterOperator.IS_EMPTY  IS_NOT_EMPTY: BaseFilterOperator.IS_NOT_EMPTY  GREATER_THAN: BaseFilterOperator.GREATER_THAN  GREATER_THAN_OR_EQUAL: BaseFilterOperator.GREATER_THAN_OR_EQUAL  LESS_THAN: BaseFilterOperator.LESS_THAN  LESS_THAN_OR_EQUAL: BaseFilterOperator.LESS_THAN_OR_EQUAL  BEFORE: BaseFilterOperator.BEFORE  AFTER: BaseFilterOperator.AFTER}

const fBase = univerAPI.getActiveBase()const fBaseTable = fBase.getTableById('table-1')const view = fBaseTable.getViewByName('Grid')view.setFilter({  conjunction: univerAPI.Enum.BaseFilterConjunction.AND,  filters: [    {      fieldId: 'fld-1',      operator: univerAPI.Enum.BaseFilterOperator.Equals,      value: 'John Doe',    },  ],})

type EnumValues = {  /** The Parent field is absent, targets another table, or allows multiple records. */  InvalidField: BaseHierarchyErrorCode.InvalidField  /** The record being changed or its requested parent does not exist. */  MissingRecord: BaseHierarchyErrorCode.MissingRecord  /** A record was assigned as its own parent. */  SelfParent: BaseHierarchyErrorCode.SelfParent  /** The requested Parent edge would create a cycle. */  Cycle: BaseHierarchyErrorCode.Cycle  /** Moving the record's subtree would exceed {@link BASE_HIERARCHY_MAX_LEVELS}. */  MaxDepth: BaseHierarchyErrorCode.MaxDepth  /** Manual record reordering was requested while the active view has Sort rules. */  SortedView: BaseHierarchyErrorCode.SortedView}

import { BaseHierarchyError } from '@univerjs-pro/bases'try {  record.setParent(table.getHierarchyFieldId(), targetRecordId)} catch (error) {  if (!(error instanceof BaseHierarchyError)) throw error  switch (error.code) {    case univerAPI.Enum.BaseHierarchyErrorCode.Cycle:      console.error('The move would create a cycle.')      break    case univerAPI.Enum.BaseHierarchyErrorCode.MaxDepth:      console.error('The hierarchy supports at most five levels.')      break    default:      console.error('The hierarchy change was rejected.', error.code)  }}

type EnumValues = {  MissingParent: BaseHierarchyInvalidReason.MissingParent  SelfParent: BaseHierarchyInvalidReason.SelfParent  Cycle: BaseHierarchyInvalidReason.Cycle  MaxDepth: BaseHierarchyInvalidReason.MaxDepth}

const projection = table.getViewByName('Grid')?.getProjection()if (projection?.type === univerAPI.Enum.BaseViewType.Grid && projection.hierarchy) {  for (const node of Object.values(projection.hierarchy.nodes)) {    if (node.invalidReason === univerAPI.Enum.BaseHierarchyInvalidReason.Cycle) {      console.warn(`Record ${node.recordId} has a cyclic Parent edge.`)    }  }}

type EnumValues = {  Parent: BaseRecordLinkRole.Parent}

const fieldId = table.getHierarchyFieldId()const field = table.getFieldById(fieldId)const config = field?.getField().configif (config?.relationRole === univerAPI.Enum.BaseRecordLinkRole.Parent) {  console.log('Hierarchy field is materialized.')}

type EnumValues = {  ASC: BaseSortDirection.ASC  DESC: BaseSortDirection.DESC}

const fBase = univerAPI.getActiveBase()const fBaseTable = fBase.getTableById('table-1')const view = fBaseTable.getViewByName('Grid')const success = view.setSort([  {    fieldId: 'priority',    direction: univerAPI.Enum.BaseSortDirection.ASC,  },])console.log(success ? 'Sort set' : 'Set sort failed')

type EnumValues = {  Grid: BaseViewType.Grid  Kanban: BaseViewType.Kanban  Calendar: BaseViewType.Calendar  Gantt: BaseViewType.Gantt  Gallery: BaseViewType.Gallery  Pivot: BaseViewType.Pivot}

const fBase = univerAPI.getActiveBase()const fBaseTable = fBase.getTableById('table-1')const view = fBaseTable.createView('API Grid', univerAPI.Enum.BaseViewType.Grid, {  view: {    id: 'grid-api',    config: {      frozenFieldCount: 1,    },  },})console.log(view)

type EnumValues = {  None: BoardBackgroundType.None  Solid: BoardBackgroundType.Solid  Gradient: BoardBackgroundType.Gradient  Image: BoardBackgroundType.Image  Pattern: BoardBackgroundType.Pattern}

type EnumValues = {  Start: 'start'  Center: 'center'  End: 'end'  Path: 'path'  /** Prefer the longest orthogonal segment; use the arc-length midpoint on other paths. */  Auto: 'auto'}

type EnumValues = {  Path: 'path'  Canvas: 'canvas'}

type EnumValues = {  /** Keep text horizontal regardless of the connector direction. */  Horizontal: 'horizontal'  /** Follow the directed tangent exactly; reversed routes can produce upside-down text. */  FollowPath: 'followPath'  /** Follow the tangent, flipping text by 180 degrees when needed to keep it upright. */  Auto: 'auto'}

type EnumValues = {  Left: 'left'  OnPath: 'onPath'  Right: 'right'}

type EnumValues = {  AutoSize: 'autoSize'  FixedWidth: 'fixedWidth'  FixedSize: 'fixedSize'}

type EnumValues = {  /** Draws a direct line between endpoints. Use only for short connections with clear space; it does not perform general obstacle avoidance. */  Straight: 'straight'  /** Draws an orthogonal elbow connector. Combine with automatic routing for normal process and dependency diagrams that need obstacle routing. */  Orthogonal: 'orthogonal'  /** Draws a curved connector. Prefer it for feedback, return, and self-loop relationships with clear arc space. */  Curve: 'curve'  /** Draws a manually controlled polyline connector. Use it only when the caller supplies the intended path. */  FreePolyline: 'freePolyline'}

console.log(univerAPI.Enum.BoardConnectorRouting.Orthogonal)

type EnumValues = {  /** Lets the board choose and refresh the route automatically. */  Auto: 'auto'  /** Keeps the caller-provided route. */  Manual: 'manual'  /** Uses a route with both automatic and manually controlled parts. */  Mixed: 'mixed'}

console.log(univerAPI.Enum.BoardConnectorRoutingMode.Auto)

type EnumValues = {  Top: 0  Right: 1  Bottom: 2  Left: 3}

console.log(univerAPI.Enum.BoardConnectorSite.Bottom)

type EnumValues = {  Generic: 'generic'  Swimlane: 'swimlane'  UMLPackage: 'uml-package'  SystemBoundary: 'system-boundary'}

type EnumValues = {  Actor: 'actor'  Boundary: 'boundary'  Control: 'control'  Entity: 'entity'  Collection: 'collection'  DataStorage1: 'data_storage_1'  DataStorage2: 'data_storage_2'  DataStorage3: 'data_storage_3'  Component: 'component'  ComponentBox: 'component_box'  ProvidedInterface: 'provided_interface'  AssemblyConnector: 'assembly_connector'  RequiredInterface: 'required_interface'  InitialState: 'initial_state'  FinalState: 'final_state'  StateBar: 'state_bar'}

type EnumValues = {  /** Move elements to the top of the z-order. */  Front: 'front'  /** Move elements one step forward in the z-order. */  Forward: 'forward'  /** Move elements one step backward in the z-order. */  Backward: 'backward'  /** Move elements to the bottom of the z-order. */  Back: 'back'}

console.log(univerAPI.Enum.BoardElementOrderPlacement.Front)

const board = univerAPI.getActiveBoard()if (!board) throw new Error('No active board')const shapeDescriptors = board.describeElements({  elementType: univerAPI.Enum.BoardElementType.Shape,})console.log(shapeDescriptors.length)

type EnumValues = {  One: 'one'  ZeroOrOne: 'zeroOrOne'  OneOrMany: 'oneOrMany'  ZeroOrMany: 'zeroOrMany'}

type EnumValues = {  Identifying: 'identifying'  NonIdentifying: 'nonIdentifying'}

type EnumValues = {  /** Align left edges. */  Left: 'left'  /** Align horizontal centers. */  Center: 'center'  /** Align right edges. */  Right: 'right'  /** Align top edges. */  Top: 'top'  /** Align vertical middles. */  Middle: 'middle'  /** Align bottom edges. */  Bottom: 'bottom'}

console.log(univerAPI.Enum.BoardFacadeElementAlignment.Left)

type EnumValues = {  /** Distribute elements along the x-axis. */  Horizontal: 'horizontal'  /** Distribute elements along the y-axis. */  Vertical: 'vertical'}

console.log(univerAPI.Enum.BoardFacadeElementDistribution.Horizontal)

type EnumValues = {  /** Connect each source layer item to every target layer item. */  Complete: 'complete'  /** Connect items by matching index. */  Pairwise: 'pairwise'  /** Connect each source item to a fan of target items. */  Fan: 'fan'}

console.log(univerAPI.Enum.BoardFacadeLayeredConnectionMode.Pairwise)

type EnumValues = {  /** Align layer items to the start of the cross-axis. */  Start: 'start'  /** Center layer items on the cross-axis. */  Center: 'center'  /** Align layer items to the end of the cross-axis. */  End: 'end'}

console.log(univerAPI.Enum.BoardFacadeLayeredLayoutAlignment.Center)

type EnumValues = {  /** Layout layers from top to bottom. */  Vertical: 'vertical'  /** Layout layers from left to right. */  Horizontal: 'horizontal'}

console.log(univerAPI.Enum.BoardFacadeLayeredLayoutDirection.Horizontal)

type EnumValues = {  /** Place the new bounds to the right of existing content. */  Right: 'right'  /** Place the new bounds below existing content. */  Below: 'below'}

const board = univerAPI.getActiveBoard()if (!board) throw new Error('No active board')const bounds = board.getNextAvailableBounds({  width: 180,  height: 100,  placement: univerAPI.Enum.BoardFacadeNextAvailableBoundsPlacement.Right,})console.log(bounds)

type EnumValues = {  Synchronous: 'synchronous'  Asynchronous: 'asynchronous'  Reply: 'reply'  Create: 'create'  Destroy: 'destroy'  Self: 'self'}

type EnumValues = {  ActorLifeline: 'sequence_actor_lifeline'  BoundaryLifeline: 'sequence_boundary_lifeline'  ControlLifeline: 'sequence_control_lifeline'  EntityLifeline: 'sequence_entity_lifeline'  CollectionLifeline: 'sequence_collection_lifeline'  ObjectLifeline: 'sequence_object_lifeline'  MagneticDiskLifeline: 'sequence_magnetic_disk_lifeline'  DirectAccessStorageLifeline: 'sequence_direct_access_storage_lifeline'  ActivationBar: 'sequence_activation_bar'}

console.log(univerAPI.Enum.BoardSequenceShapeType.ObjectLifeline)

type EnumValues = {  /** Lanes are stacked from top to bottom. */  Horizontal: 'horizontal'  /** Lanes are arranged from left to right. */  Vertical: 'vertical'}

console.log(univerAPI.Enum.BoardSwimlaneOrientation.Horizontal)

console.log(univerAPI.Enum.BoardToolType.Shape)

type EnumValues = {  Association: 'association'  DirectedAssociation: 'directedAssociation'  Aggregation: 'aggregation'  Composition: 'composition'  Generalization: 'generalization'  Realization: 'realization'  Dependency: 'dependency'}

type EnumValues = {  /** Rounded elbow branches. */  RoundedOrthogonal: 'rounded-orthogonal'  /** Curved branches. */  Curve: 'curve'  /** Sharp elbow branches. */  Orthogonal: 'orthogonal'}

console.log(univerAPI.Enum.BoardMindMapBranchLineType.Curve)

type EnumValues = {  /** Left side of the parent. */  Left: 'left'  /** Right side of the parent. */  Right: 'right'  /** Top side of the parent. */  Top: 'top'  /** Bottom side of the parent. */  Bottom: 'bottom'}

const side = univerAPI.Enum.BoardMindMapNodeSide.Rightconsole.log(side)

type EnumValues = {  /** Horizontal two-sided mind map. */  MindMapHorizontal: 'mindmap-horizontal'  /** Vertical mind map. */  MindMapVertical: 'mindmap-vertical'  /** Right-growing tree. */  TreeRight: 'tree-right'  /** Left-growing tree. */  TreeLeft: 'tree-left'  /** Alternating-side tree. */  TreeAlternate: 'tree-alternate'  /** Horizontal timeline. */  TimelineHorizontal: 'timeline-horizontal'  /** Vertical timeline. */  TimelineVertical: 'timeline-vertical'}

console.log(univerAPI.Enum.BoardMindMapStructureKind.TreeRight)

type EnumValues = {  /** Continuous border line. */  Solid: SlideTableBorderDashEnum.Solid  /** Dashed border line. */  Dash: SlideTableBorderDashEnum.Dash  /** Dotted border line. */  Dot: SlideTableBorderDashEnum.Dot  /** Alternating dash and dot border line. */  DashDot: SlideTableBorderDashEnum.DashDot  /** Remove the selected border. */  None: SlideTableBorderDashEnum.None}

const dash = univerAPI.Enum.BoardTableBorderDashEnum.Dashconsole.log(dash)

const preset = univerAPI.Enum.BoardTableBorderPresetEnum.Allconsole.log(preset)

type EnumValues = {  /** UML class box with name, attributes, and operations sections. */  UMLClass: BoardDiagramTablePreset.UMLClass  /** UML interface box with stereotype, name, and operations sections. */  UMLInterface: BoardDiagramTablePreset.UMLInterface  /** UML sequence-diagram frame with one labeled content region. */  UMLSequenceFragment: BoardDiagramTablePreset.UMLSequenceFragment  /** UML sequence-diagram alternative frame with multiple guarded regions. */  UMLSequenceAlternativeFragment: BoardDiagramTablePreset.UMLSequenceAlternativeFragment  /** Compact ER entity box containing an entity name. */  ERDEntity: BoardDiagramTablePreset.ERDEntity  /** ER field row with a dedicated primary/foreign key column. */  ERDKeyField: BoardDiagramTablePreset.ERDKeyField  /** ER field row with separate field-name and data-type columns. */  ERDFieldType: BoardDiagramTablePreset.ERDFieldType  /** Full ER entity table with name, key, field, and data-type columns. */  ERDFull: BoardDiagramTablePreset.ERDFull}

console.log(univerAPI.Enum.BoardTableDiagramPreset.UMLClass)

type EnumValues = {  /** Do not paint a cell fill. */  None: SlideTableFillTypeEnum.None  /** Paint one solid color. */  Solid: SlideTableFillTypeEnum.Solid  /** Paint a gradient defined by type, angle, and color stops. */  Gradient: SlideTableFillTypeEnum.Gradient  /** Paint an image using stretch or tile placement. */  Picture: SlideTableFillTypeEnum.Picture}

const fill = univerAPI.Enum.BoardTableFillTypeEnum.Solidconsole.log(fill)

type EnumValues = {  /** Linear gradient along an angle. */  Linear: SlideTableGradientFillTypeEnum.Linear  /** Radial gradient expanding from a center point. */  Radial: SlideTableGradientFillTypeEnum.Radial  /** Angular gradient rotating around a center point. */  Angular: SlideTableGradientFillTypeEnum.Angular  /** Diamond-shaped gradient expanding toward the corners. */  Diamond: SlideTableGradientFillTypeEnum.Diamond}

const gradientType = univerAPI.Enum.BoardTableGradientFillTypeEnum.Linearconsole.log(gradientType)

type EnumValues = {  /** Scale one image to cover the cell fill area. */  Stretch: SlideTablePictureFillModeEnum.Stretch  /** Repeat the image as tiles inside the cell fill area. */  Tile: SlideTablePictureFillModeEnum.Tile}

const pictureMode = univerAPI.Enum.BoardTablePictureFillModeEnum.Stretchconsole.log(pictureMode)

type EnumValues = {  /** Render text from left to right using normal horizontal lines. */  Horizontal: SlideTableTextDirectionEnum.Horizontal  /** Stack or rotate text vertically from top to bottom. */  Vertical: SlideTableTextDirectionEnum.Vertical  /** Render vertical text in the opposite 270-degree direction. */  Vertical270: SlideTableTextDirectionEnum.Vertical270  WordArtVertical: SlideTableTextDirectionEnum.WordArtVertical}

const direction = univerAPI.Enum.BoardTableTextDirectionEnum.Verticalconsole.log(direction)

type EnumValues = {  /** Align cell content to the top edge. */  Top: SlideTableVerticalAlignEnum.Top  /** Center cell content vertically. */  Middle: SlideTableVerticalAlignEnum.Middle  /** Align cell content to the bottom edge. */  Bottom: SlideTableVerticalAlignEnum.Bottom}

const alignment = univerAPI.Enum.BoardTableVerticalAlignEnum.Middleconsole.log(alignment)

type EnumValues = {  Editing: BoardInteractionMode.Editing  Viewing: BoardInteractionMode.Viewing}

type EnumValues = {  NOT_COLLAB: CollaborationStatus.NOT_COLLAB  SYNCED: CollaborationStatus.SYNCED  PENDING: CollaborationStatus.PENDING  AWAITING: CollaborationStatus.AWAITING  AWAITING_WITH_PENDING: CollaborationStatus.AWAITING_WITH_PENDING  FETCH_MISS: CollaborationStatus.FETCH_MISS  CONFLICT: CollaborationStatus.CONFLICT  OFFLINE: CollaborationStatus.OFFLINE}

type EnumValues = {  Selection: DocChartInsertAnchorKind.Selection  BodyOffset: DocChartInsertAnchorKind.BodyOffset  Paragraph: DocChartInsertAnchorKind.Paragraph  TextRange: DocChartInsertAnchorKind.TextRange}

const fDocument = univerAPI.getActiveDocument()const chartInfo = fDocument  .newChart(univerAPI.Enum.ChartTypeString.Column)  .setSource([    ['Quarter', 'Sales'],    ['Q1', 120],    ['Q2', 180],  ])  .setPosition({    kind: univerAPI.Enum.DocsChartInsertAnchorKind.BodyOffset,    offset: 0,  })  .setInline()  .setSize(640, 360)  .build()await fDocument.insertChart(chartInfo)

type EnumValues = {  /** Places the object in the text flow like a character and lets it affect the containing line's metrics. */  INLINE: PositionedObjectLayoutType.INLINE  /** Floats the object without reflowing text. The object and text can overlap. */  WRAP_NONE: PositionedObjectLayoutType.WRAP_NONE  /** Floats the object and wraps text around the custom polygon defined by its wrap path. */  WRAP_POLYGON: PositionedObjectLayoutType.WRAP_POLYGON  /** Floats the object and wraps text around its rectangular bounds. */  WRAP_SQUARE: PositionedObjectLayoutType.WRAP_SQUARE  /** Floats the object and allows text to flow through eligible open regions in its wrap contour. */  WRAP_THROUGH: PositionedObjectLayoutType.WRAP_THROUGH  /** Floats the object and wraps text closely around its contour instead of its rectangular bounds. */  WRAP_TIGHT: PositionedObjectLayoutType.WRAP_TIGHT  /** Floats the object in a horizontal band, leaving text only above and below it. */  WRAP_TOP_AND_BOTTOM: PositionedObjectLayoutType.WRAP_TOP_AND_BOTTOM}

const fDocument = univerAPI.getActiveDocument()const chartInfo = fDocument  .newChart(univerAPI.Enum.ChartTypeString.Line)  .setSource([    ['Month', 'Sales'],    ['Jan', 120],    ['Feb', 180],  ])  .setLayout({    layoutType: univerAPI.Enum.DocsChartLayoutType.WRAP_SQUARE,    position: { x: 120, y: 80 },    width: 640,    height: 360,  })  .build()await fDocument.insertChart(chartInfo)

type EnumValues = {  LEFT: ColumnPosition.LEFT  RIGHT: ColumnPosition.RIGHT}

const fDocument = univerAPI.getActiveDocument()const group = fDocument.findColumnGroupByText('Launch')const columns = group.getColumns()if (columns.length > 0) {  const rightColumn = group.getColumn(columns.length - 1)  const inserted = group.addColumn(    rightColumn.getId(),    univerAPI.Enum.DocsColumnPositionEnum.LEFT,    'new-column',  )  console.log(inserted?.getInsertOffset())}

type EnumValues = {  Item: DocsListSelectionMode.Item  Level: DocsListSelectionMode.Level  List: DocsListSelectionMode.List}

const fDocument = univerAPI.getActiveDocument()const item = fDocument?.findListItemByText('Todo')item?.select(univerAPI.Enum.DocsListSelectionMode.Level)