plugin.d.ts

import './mg-dsl.d'
import './mg-comp-temp.d'

declare global {
  /**
   * @deprecated please use mg instead
   */
  const mastergo: PluginAPI

  const mg: PluginAPI
  const console: Console
  const __html__: string

  function setTimeout(callback: Function, timeout: number): number
  function clearTimeout(timeoutID: number): void
  function setInterval(callback: Function, timeout: number): number
  function clearInterval(timeoutID: number): void
  function requestAnimationFrame(cb: (ts: number) => void): number
  function cancelAnimationFrame(requestID: number): void

  interface Console {
    log(message?: any, ...optionalParams: any[]): void
    error(message?: any, ...optionalParams: any[]): void
    assert(condition?: boolean, message?: string, ...data: any[]): void
    info(message?: any, ...optionalParams: any[]): void
    warn(message?: any, ...optionalParams: any[]): void
    clear(): void
  }

  interface ConfirmAction {
    label: string
    type: 'primary' | 'text'
    action: () => void
  }

  interface PromptAction {
    label: string
    type: 'primary' | 'text'
    action: (value: string) => void
  }

  interface Image {
    readonly href: string
    getBytesAsync(): Promise<Uint8Array>
  }

  type ThemeColor = 'dark' | 'light'

  type LayoutInfo = {
    leftbar: number
    rightbar: number
    canvas: number
    window: number
    height: number
    topbar: number
  }

  type MGEventCallbackMap = {
    selectionchange: (selectionLayerIds: string[]) => void
    layoutchange: (layoutInfo: LayoutInfo) => void
    currentpagechange: (pageId: string) => void
    themechange: (theme: ThemeColor) => void
    drop: (event: DropEvent) => void
    run: (command: { command: string }) => void
    close: () => void
    beforeReadyForDev: (
      sectionLayerId: string,
      callback: (setReady: boolean) => void
    ) => void
  }

  type PluginEventType = keyof MGEventCallbackMap

  interface VariableAPI {
    // --- Collection ---
    createCollection(name?: string): Promise<Collection | null>
    getCollections(includeExternal?: boolean): Collection[]
    getCollectionById(id?: string): Collection | null
    deleteCollection(collectionId: string): void
    renameCollection(collectionId: string, name: string): void
    moveCollection(
      collectionId: string,
      options?: { afterId?: string; index?: number }
    ): void

    // --- Mode ---
    getModes(collectionId?: string): CollectionMode[]
    getModeById(
      collectionId?: string,
      modeId?: string
    ): CollectionMode | null
    addMode(
      collectionId: string,
      name?: string
    ): Promise<CollectionMode | null>
    renameMode(collectionId: string, modeId: string, name: string): void
    deleteMode(collectionId: string, modeId: string): void
    setVariableMode(collectionId: string, modeId: string): void
    setPageVariableMode(
      collectionId: string,
      modeId: string,
      pageId?: string
    ): void
    /**
     * 获取指定图层上使用的变量集合及其生效模式
     * @param layerId 图层 id
     */
    getLayerVariableModes(layerId: string): LayerVariableMode[]

    // --- Group ---
    getGroupList(collectionId?: string): VariableGroupNode[]
    createGroup(
      collectionId: string,
      variableIds: string[],
      groupName?: string
    ): void
    addVariablesToGroup(
      collectionId: string,
      groupPath: string,
      variableIds: string[]
    ): void
    removeVariablesFromGroup(
      collectionId: string,
      groupPath: string,
      variableIds: string[]
    ): void
    disbandGroup(
      collectionId: string,
      groupPath?: string,
      variableIds?: string[]
    ): void
    renameGroup(
      collectionId: string,
      newName: string,
      groupPath?: string,
      variableIds?: string[]
    ): void
    deleteGroup(
      collectionId: string,
      groupPath?: string,
      variableIds?: string[]
    ): void

    // --- Variable ---
    createVariable(options: {
      name: string
      type: VariableType
      value?: any
      description?: string
      collectionId?: string
    }): Promise<Variable | null>
    getVariableById(id: string): Variable | null
    getVariables(options?: {
      collectionId?: string
      groupPath?: string
      type?: VariableType
      scopeType?: string
    }): Variable[]
    setVariableReference(options: {
      id: string
      reference: string | object
      modeId?: string
      index?: string
      /**
       * TEXT 变量子属性: 'fontFamily' | 'fontWeight' | 'fontSize' | 'lineHeight' | 'letterSpacing' | 'paragraphSpacing'。
       * 图层文本内容请改用 setVariableReferenceInLayer 的 textProperty: 'textContent'。
       */
      textProperty?: string
      strokeProperty?: string
      radiusProperty?: string
      paddingProperty?: string
      gridProperty?: string
      effectProperty?: string
    }): void
    unlinkVariable(options: {
      id: string
      modeId?: string
    }): Promise<void>
    renameVariable(variableId: string, name: string): void
    /**
     * TEXT 变量支持通过 TextVariableValue 更新文字样式属性。
     */
    setVariableValue(options: {
      id: string
      value: VariableValue
      modeId: string
    }): Promise<Variable | null>
    addVariableValue(options: {
      id: string
      value?: any
      modeId: string
    }): Variable | null
    deleteVariableValue(options: {
      id: string
      index: string | string[]
      modeId: string
    }): Variable | null
    deleteVariable(variableId: string): void
    moveVariable(
      variableId: string,
      options?: { afterId?: string; index?: number }
    ): Promise<void>

    // --- Variable Description / Alias ---
    getVariableDescription(variableId: string): string | null
    setVariableDescription(
      variableId: string,
      value: string
    ): Promise<Variable | null>
    resetVariableDescription(
      variableId: string
    ): Promise<Variable | null>
    getVariableAlias(variableId: string): string | null
    setVariableAlias(
      variableId: string,
      value: string
    ): Promise<Variable | null>
    resetVariableAlias(variableId: string): Promise<Variable | null>

    // --- Component Property Variable ---
    setVariableInComponent(options: {
      id: string
      propertyId: string
      type: 'BOOLEAN' | 'CONTENT'
    }): void
    unlinkVariableInComponent(options: {
      propertyId: string
      type: 'BOOLEAN' | 'CONTENT'
    }): void
    createVariableInComponent(options: {
      name: string
      description?: string
      collectionId?: string
      layerId: string
      type: 'BOOLEAN' | 'CONTENT'
      value?: any
    }): Promise<string | null>

    // --- Layer Property Variable ---
    createVariableInLayer(options: {
      name: string
      description?: string
      collectionId?: string
      layerId: string
      value?: any
      strokeProperty?: string
      radiusProperty?: string
      paddingProperty?: string
      dimensionProperty?: string
      baseProperty?: string
      effectProperty?: string
      gridProperty?: string
      /**
       * 文字属性: 'fontFamily' | 'fontWeight' | 'fontSize' | 'lineHeight' | 'letterSpacing' | 'paragraphSpacing' | 'textContent'。
       * 'textContent' 作用于图层文本内容，需使用 STRING 变量。
       */
      textProperty?: string
      index?: number
    }): Promise<Variable | null>
    /**
     * 将已有变量绑定到图层属性。
     *
     * `id` 支持两种取值：
     * - 本地变量 id（如 `getVariables()` 返回的 `Variable.id`）
     * - 团队库变量 ukey（`getTeamLibraryAsync()` 返回的 `style.colors/numbers/strings/bools` 等条目的 `ukey`）。
     *   传入 ukey 时会自动将该团队库变量导入当前文件后再绑定；
     *   需要当前文件已订阅对应团队库，下载失败时 Promise reject。
     */
    setVariableReferenceInLayer(options: {
      id: string
      layerId: string
      strokeProperty?: string
      radiusProperty?: string
      paddingProperty?: string
      dimensionProperty?: string
      baseProperty?: string
      effectProperty?: string
      gridProperty?: string
      /**
       * 文字属性: 'fontFamily' | 'fontWeight' | 'fontSize' | 'lineHeight' | 'letterSpacing' | 'paragraphSpacing' | 'textContent'。
       * 'textContent' 将 STRING 变量绑定到图层文本内容。
       */
      textProperty?: string
      index?: number
    }): Promise<void>
    unlinkVariableReferenceInLayer(options: {
      layerId: string
      strokeProperty?: string
      radiusProperty?: string
      paddingProperty?: string
      dimensionProperty?: string
      baseProperty?: string
      effectProperty?: string
      gridProperty?: string
      /**
       * 文字属性: 'fontFamily' | 'fontWeight' | 'fontSize' | 'lineHeight' | 'letterSpacing' | 'paragraphSpacing' | 'textContent'。
       * 'textContent' 解除图层文本内容上的 STRING 变量引用。
       */
      textProperty?: string
      index?: number
    }): Promise<void>

    // --- Variable Code Syntax ---
    getCodeSyntax(variableId: string): VariableCodeSyntax | null
    setCodeSyntax(
      variableId: string,
      codeSyntax: { web?: string; android?: string; ios?: string }
    ): Promise<Variable | null>
    resetCodeSyntax(
      variableId: string,
      platform?: string
    ): Promise<Variable | null>

    // --- Variable Scopes ---
    getVariableScopes(variableId: string): ScopeName[]
    setVariableScopes(
      variableId: string,
      scopes: ScopeName[]
    ): Promise<Variable | null>

    // --- Variable Indexes ---
    getVariableIndexes(
      variableId: string,
      modeId?: string
    ): string[]

    // --- Font ---
    getFontFamilies(): FontFamilyInfo[]
    getFontWeights(fontFamily: string): FontWeightInfo[]
  }

  interface PluginAPI {
    readonly document: DocumentNode

    readonly ui: UIAPI

    readonly themeColor: ThemeColor

    readonly apiVersion: string

    readonly documentId: number

    readonly pluginId: number

    readonly command: string

    readonly mixed: string | symbol

    readonly clientStorage: ClientStorageAPI

    readonly WebSocket: WebSocketAPI

    readonly currentUser: User | null

    readonly viewport: ViewportAPI

    /**
     * @note only available in devMode
     */
    readonly codegen?: CodegenAPI

    readonly snippetgen?: SnippetgenAPI

    readonly mode?: 'inspect' | 'design' | 'codegen' | 'snippetgen'

    closePlugin(): void

    on<T extends PluginEventType>(
      type: T,
      callback: MGEventCallbackMap[T]
    ): void
    once<T extends PluginEventType>(
      type: T,
      callback: MGEventCallbackMap[T]
    ): void
    off<T extends PluginEventType>(
      type?: T,
      callback?: MGEventCallbackMap[T]
    ): void

    commitUndo(): void
    triggerUndo(): void

    showUI(html: string, options?: ShowUIOptions): void

    getNodeById<T extends SceneNode>(id: string): T | null
    getNodeByPosition(position: { x: number; y: number }): SceneNode | null
    getRootNodeById<T extends SceneNode>(id: string): T | null
    getRootParentLayerId(id: string): string | null
    getTopContainerInfoListByPageID(pageID: string): TopContainerInfo[] | null
    createRectangle(): RectangleNode
    createLine(): LineNode
    createEllipse(): EllipseNode
    createPolygon(): PolygonNode
    createStar(): StarNode
    createPen(): PenNode
    createText(): TextNode
    createFrame(children?: SceneNode[]): FrameNode
    createComponent(children?: SceneNode[]): ComponentNode
    createSection(): SectionNode
    createPage(): PageNode
    createSlice(): SliceNode
    createConnector(): ConnectorNode
    createIntelligentContainer(children?: SceneNode[]): IntelligentContainerNode
    createNodeFromSvgAsync(svg: string): Promise<FrameNode>

    combineAsVariants(nodes: ComponentNode[]): ComponentSetNode

    getHoverLayer(): PageNode | SceneNode

    /**
     * @deprecated
     * This function is deprecated, please use viewport.layoutGridVisible instead.
     */
    showGrid(show: boolean): void

    group(children: SceneNode[]): GroupNode
    union(children: SceneNode[]): BooleanOperationNode
    subtract(children: SceneNode[]): BooleanOperationNode
    intersect(children: SceneNode[]): BooleanOperationNode
    exclude(children: SceneNode[]): BooleanOperationNode
    flatten(nodes: SceneNode[]): PenNode | null

    saveVersionHistoryAsync(desc: string, title?: string): Promise<void>

    notify(message: string, options?: NotifyOptions): NotificationHandler

    getStyleById(id: string): Style | null
    getStyleCodeById(id: string, options?: StyleCodeOptions): CodeString | null
    getWebStyleCodeById(
      id: string,
      options?: WebStyleCodeOptions
    ): CodeString | null
    getAndroidStyleCodeById(
      id: string,
      options?: AndroidStyleCodeOptions
    ): CodeString | null
    getIOSStyleCodeById(
      id: string,
      options?: IOSStyleCodeOptions
    ): CodeString | null
    getTitleByFontFamilyAndStyle(
      fontFamily: string,
      fontStyle: string
    ): FontAlias | null

    createFillStyle(config: CreateStyleConfig): PaintStyle
    createEffectStyle(config: CreateStyleConfig): EffectStyle
    createTextStyle(config: CreateStyleConfig): TextStyle
    createGridStyle(config: CreateStyleConfig): GridStyle
    createCornerRadiusStyle(config: CreateStyleConfig): CornerRadiusStyle
    createPaddingStyle(config: CreateStyleConfig): PaddingStyle
    createSpacingStyle(config: CreateStyleConfig): SpacingStyle

    /**
     * @deprecated please use createStrokeFillStyle instead
     */
    createStrokeStyle(config: CreateStyleConfig): PaintStyle
    createStrokeFillStyle(config: CreateStyleConfig): PaintStyle
    createStrokeWidthStyle(config: CreateStyleConfig): StrokeWidthStyle

    /**
     * createFillStyle/createStrokeFillStyle 这些函数的聚合函数，传入不同的 type，返回对应的 style
     * @param layerId
     * @param type NodeStyleType
     * @param styleName
     * @param description optional
     * @param collectionId optional
     */
    createStyleByLayer<T extends NodeStyleType>(
      layerId: string,
      type: T,
      styleName: string,
      description?: string,
      collectionId?: string
    ): NodeStyleReturnType<T>

    /**
     * 创建一个新的默认样式，不依赖某一个图层中的样式，
     * eg: createStyle('PAINT', 'New Style', 'This is a new style')
     * @param type styleType
     * @param styleName
     * @param description optional
     * @param collectionId optional
     */
    createStyle<T extends StyleType>(
      type: T,
      styleName: string,
      description?: string,
      collectionId?: string
    ): StyleReturnType<T>
    /**
     * 创建某一个样式的副本
     * @param sourceStyleId 副本的源样式id
     * @param type
     * @param styleName
     * @param description
     */
    createStyleCopy<T extends StyleType = 'PAINT'>(
      sourceStyleId: string,
      styleName?: string,
      description?: string
    ): StyleReturnType<T>

    getLocalPaintStyles(): PaintStyle[]
    getLocalEffectStyles(): EffectStyle[]
    getLocalTextStyles(): TextStyle[]
    getLocalGridStyles(): GridStyle[]
    getLocalStrokeWidthStyles(): StrokeWidthStyle[]
    getLocalCornerRadiusStyles(): CornerRadiusStyle[]
    getLocalPaddingStyles(): PaddingStyle[]
    getLocalSpacingStyles(): SpacingStyle[]

    readonly variables: VariableAPI

    listAvailableFontsAsync(): Promise<Font[]>
    loadFontAsync(fontName: FontName): Promise<boolean>
    createImage(imageData: Uint8Array, isSync?: boolean): Promise<Image>
    getImageByHref(href: string): Image

    /**
     * 导出多个图层组成的png图片, 可过滤图层id，设置导出图片的缩放倍率
     */
    exportPng(params: GlobalExportPngSetting): string;
    /**
     * 导出多个图层组成的svg图片
     * @param layerIds 图层id数组
     */
    exportSvgByLayerIds(layerIds: string[]): string

    getTeamLibraryAsync(): Promise<TeamLibrary>
    getPublishedTeamLibraryAsync(): Promise<PublishedTeamLibrary | null>
    importComponentByKeyAsync(ukey: string): Promise<ComponentNode>
    importComponentSetByKeyAsync(ukey: string): Promise<ComponentSetNode>
    importStyleByKeyAsync(ukey: string): Promise<Style>
    getComponentListVal(): ComponentItemVal[]
    /**
     * @deprecated
     *
     * This attribute is deprecated, please use getTeamLibraryAsync instead.
     */
    teamLibrary: TeamLibrary

    hexToRGBA(hex: string): RGBA
    RGBAToHex(rgba: RGBA): string

    confirm: (
      message: string,
      options: [ConfirmAction, ...ConfirmAction[]]
    ) => void
    prompt: (
      message: string,
      defaultValue: string,
      options: [PromptAction, ...PromptAction[]]
    ) => void
  }

  interface GlobalExportPngSetting {
    ids?: string[];
    filterIds?: string[];
    scale?: number;
  }

  interface User {
    id: string | null
    name: string | 'Anonymous'
    photoUrl: string | null
  }

  interface Rect extends Readonly<Bound> {}
  interface NotificationHandler {
    cancel: () => void
  }
  interface Layout {
    canvas: number
    leftbar: number
    rightbar: number
    window: number
  }

  interface PositionOnDom {
    width: number
    height: number
    x: number
    y: number
  }

  interface ViewportAPI {
    center: Vector
    zoom: number
    readonly bound: Rect
    /**
     * @deprecated
     */
    readonly layout: Layout
    readonly positionOnDom: PositionOnDom
    rulerVisible: boolean
    layoutGridVisible: boolean
    scrollAndZoomIntoView(nodes: SceneNode[]): void
  }

  interface ClientStorageAPI {
    getAsync(key: string): Promise<any | undefined>
    setAsync(key: string, value: any): Promise<void>
    deleteAsync(key: string): Promise<void>
    keysAsync(): Promise<string[]>
  }

  interface WebSocketHandle {
    readonly readyState: number
    readonly url: string
    readonly protocol: string

    onopen: ((self: WebSocketHandle, event: { type: string }) => void) | undefined
    onmessage: ((self: WebSocketHandle, data: any) => void) | undefined
    onclose: ((self: WebSocketHandle, event: { code: number; reason: string; wasClean: boolean }) => void) | undefined
    onerror: ((self: WebSocketHandle, event: { type: string }) => void) | undefined

    send(data: any): void
    close(code?: number, reason?: string): void
  }

  interface WebSocketAPI {
    CONNECTING: 0
    OPEN: 1
    CLOSING: 2
    CLOSED: 3

    connect(url: string, protocols?: string | string[]): WebSocketHandle
  }

  type ShowUIOptions = {
    width?: number
    height?: number
    visible?: boolean
    x?: number | string
    y?: number | string
  }

  interface ExportSettingsConstraints {
    type: 'SCALE' | 'WIDTH' | 'HEIGHT'
    value: number
  }

  interface ExportSettingsImage {
    readonly format: 'JPG' | 'PNG' | 'WEBP'
    readonly isSuffix?: boolean
    readonly fileName?: string
    readonly constraint?: ExportSettingsConstraints
    readonly useAbsoluteBounds?: boolean // defaults to true
    readonly useRenderBounds?: boolean // default to true
  }
  interface ExportSettingsSVG {
    readonly format: 'SVG'
    readonly isSuffix?: boolean
    readonly fileName?: string
  }

  interface ExportSettingsPDF {
    readonly format: 'PDF'
    readonly isSuffix?: string
    readonly fileName?: string
    readonly useAbsoluteBounds?: boolean // defaults to true
    readonly useRenderBounds?: boolean // default to true
  }

  type ExportSettings =
    | ExportSettingsImage
    | ExportSettingsSVG
    | ExportSettingsPDF

  interface PageExportItem {
    /** 导出项 ID */
    readonly id: string
    /** 导出项对应的节点 ID；页面导出项对应页面 ID */
    readonly layerId: string
    /** 导出项对应的图层名称 */
    readonly layerName?: string
    /** 导出的文件名或前后缀 */
    readonly fileName: string
    /** 导出文件格式；SOURCE 表示源文件项 */
    readonly format: ExportSettings['format'] | 'SOURCE'
    /** 是否为图层导出项；false 表示页面导出项 */
    readonly isLayer: boolean
    /** 是否将 fileName 作为后缀 */
    readonly isSuffix: boolean
    /** 导出尺寸约束 */
    readonly constraint?: ExportSettingsConstraints
    readonly width?: number
    readonly height?: number
    readonly quality?: number
    readonly isBKVisible?: boolean
  }

  interface ExportMixin {
    exportSettings: ReadonlyArray<ExportSettings>
    export(settings?: ExportSettings): Uint8Array | string // Defaults to PNG format
    exportAsync(settings?: ExportSettings): Promise<Uint8Array | string>
    exportPng(settings?: Omit<GlobalExportPngSetting, 'ids'>): string
  }

  interface NotifyOptions {
    position?: 'top' | 'bottom'
    type?: 'normal' | 'highlight' | 'error' | 'warning' | 'success'
    timeout?: number
    isLoading?: boolean
  }

  type CodeType = 'Web' | 'iOS' | 'Android'

  type WebCodeLang = 'css' | 'less' | 'sass'
  type AndroidCodeLang = 'xml'
  type IOSCodeLang = 'swift'
  type CodeLang = WebCodeLang | AndroidCodeLang | IOSCodeLang

  type WebCodeUnit = 'px' | 'rem' | 'rpx'
  type AndroidCodeUnit = 'dp' | 'dp/sp'
  type IOSCodeUnit = 'pt'
  type CodeUnit = WebCodeUnit | AndroidCodeUnit | IOSCodeUnit

  interface StyleCodeOptions {
    codeType?: CodeType
    codeLang?: CodeLang
    unit?: CodeUnit
    pixelRatio?: number
  }

  interface WebStyleCodeOptions {
    codeLang?: WebCodeLang
    unit?: WebCodeUnit
    pixelRatio?: number
  }

  interface AndroidStyleCodeOptions {
    pixelRatio?: number
  }

  interface IOSStyleCodeOptions {
    pixelRatio?: number
  }

  type CodeData = {
    layout?: string
    style?: string
    typography?: string
    other?: string
  }
  interface CodeString {
    type: 'CSS' | 'iOS' | 'Android'
    data: CodeData | ''
  }

  interface UIViewport extends Bound {
    readonly headerHeight: number
    readonly visible: boolean
  }

  interface CloseConfirmOptions {
    /** 是否开启关闭确认（离开挽留） */
    enabled: boolean
    /** 可选：自定义确认框文案，不传使用默认文案 */
    message?: string
  }
  interface UIAPI {
    show(): void
    hide(): void
    close(): void
    resize(width: number, height: number): void
    moveTo(x: number, y: number): void
    viewport: UIViewport
    postMessage(pluginMessage: any, origin?: string): void
    onmessage: ((pluginMessage: any, origin: string) => void) | undefined
    /**
     * 设置关闭插件前的「离开挽留」确认。
     * enabled 为 true 时，用户点击关闭按钮或调用 mg.closePlugin()，
     * 宿主会弹出确认框，确认后才真正关闭。
     * 插件出现未保存内容时开启，保存完成或无需挽留时关闭。
     */
    setCloseConfirm(options: CloseConfirmOptions): void
  }
  type PublishStatus = 'UNPUBLISHED' | 'CURRENT' | 'CHANGED'
  interface DocumentationLink {
    readonly uri: string
  }
  interface PublishableMixin {
    description: string
    documentationLinks: ReadonlyArray<DocumentationLink>
    /**
     * @description 组件或者组件集的别名
     */
    alias: string

    /**
     * @description 是否为团队库组件/样式
     */
    readonly isExternal: boolean
    readonly ukey: string
    readonly publishStatus: PublishStatus
  }

  // Styles
  type StyleType =
    | 'PAINT'
    | 'TEXT'
    | 'EFFECT'
    | 'GRID'
    | 'STROKE_WIDTH'
    | 'CORNER_RADIUS'
    | 'PADDING'
    | 'SPACING'
  type NodeStyleType =
    | 'fill'
    | 'strokeFill'
    | 'strokeWidth'
    | 'cornerRadius'
    | 'padding'
    | 'spacing'
    | 'effect'
    | 'text'
    | 'grid'

  // #region Variable / Collection / Mode / Group types

  type VariableType =
    | 'STRING'
    | 'BOOLEAN'
    | 'COLOR'
    | 'NUMBER'
    | 'PAINT'
    | 'TEXT'
    | 'EFFECT'
    | 'GRID'
    | 'STROKE_WIDTH'
    | 'CORNER_RADIUS'
    | 'PADDING'
    | 'SPACING'

  type ScopeName =
    | 'all'
    | 'fill'
    | 'fillAll'
    | 'shapeFill'
    | 'textFill'
    | 'stroke'
    | 'effect'
    | 'grid'
    | 'widthHeight'
    | 'cornerRadius'
    | 'opacity'
    | 'layoutSpacing'
    | 'layoutPadding'
    | 'fontSize'
    | 'fontWeight'
    | 'textLineHeight'
    | 'textLetterSpacing'
    | 'textParagraphSpacing'
    | 'fontFamily'
    | 'textContent'

  interface VariableCodeSyntax {
    readonly web?: string
    readonly android?: string
    readonly ios?: string
  }

  interface Variable {
    readonly id: string
    readonly name: string
    readonly description: string
    readonly alias: string
    readonly type: VariableType
    readonly collectionId: string
    readonly isExternal: boolean
    readonly supportScope: boolean
    readonly codeSyntax?: VariableCodeSyntax
    readonly scopes?: ReadonlyArray<ScopeName>
    readonly modes: Record<string, ReadonlyArray<any>>
  }

  interface TextVariableFeatures {
    /** 字形连笔 */
    liga?: number
    /** 字偶距 */
    kern?: number
    /** 全宽 */
    fwid?: number
    /** 半宽 */
    hwid?: number
    /** 其他 OpenType 字体特性 */
    [feature: string]: number | undefined
  }

  interface TextVariableValue {
    /** 文字装饰 */
    decoration?: TextDecoration
    /** 字母大小写 */
    textCase?: TextCase
    /** OpenType 字体特性 */
    features?: TextVariableFeatures
    /** 字号 */
    fontSize?: number
    /** 行高，支持像素值或百分比 */
    height?: number | string
    /** 字间距，支持像素值或百分比 */
    letterSpacing?: number | string
    /** 字重 */
    fontWeight?: number | string
    /** 字体族 */
    fontFamily?: string
  }

  type VariableValue =
    | boolean
    | number
    | string
    | RGBA
    | ReadonlyArray<number>
    | TextVariableValue
    | Record<string, unknown>
    | null

  interface Collection {
    readonly id: string
    readonly name: string
    readonly isExternal: boolean
    readonly modes: ReadonlyArray<CollectionMode>
  }

  interface CollectionMode {
    readonly id: string
    readonly name: string
    readonly collectionId: string
  }

  interface LayerVariableMode {
    /** 集合 id */
    readonly collectionId: string
    /** 当前实际生效（渲染）的模式 id，为 null 时表示多值 */
    readonly modeId: string | null
    /**
     * 模式名称，从集合的模式列表中按 modeId 解析（团队库集合同样支持）。
     * modeId 为 null（多值）或模式已被删除等无法解析时缺失。
     */
    readonly modeName?: string
    /** 是否为图层显式指定的模式，false 表示跟随父级（自动） */
    readonly isExplicit: boolean
    /** 跟随父级时，父级的模式 id */
    readonly parentModeId: string | null
  }

  interface VariableGroupNode {
    readonly id: string
    readonly name: string
    readonly currentPath?: string
    readonly level: number
    readonly isLeaf: boolean
    readonly children?: ReadonlyArray<VariableGroupNode>
  }

  interface FontFamilyInfo {
    readonly family: string
    readonly label: string
    readonly lang: string
    readonly isVariable: boolean
  }

  interface FontWeightInfo {
    readonly postscriptName: string
    readonly label: string
    readonly style: string
    readonly weight: number
    readonly slant: number
  }

  // #endregion

  interface BaseStyle extends Omit<PublishableMixin, 'documentationLinks'> {
    readonly id: string
    readonly type: StyleType
    /** 样式所属集合的 id */
    readonly collectionId: string
    /** 样式所属集合的名称 */
    readonly collectionName: string
    name: string
    remove(): void
  }

  interface PaintStyle extends BaseStyle {
    type: 'PAINT'
    paints: ReadonlyArray<Paint>
  }

  interface StrokeWidthStyle extends BaseStyle {
    type: 'STROKE_WIDTH'
    value: StrokeWidth
  }

  interface CornerRadiusStyle extends BaseStyle {
    type: 'CORNER_RADIUS'
    value: CornerRadius
  }

  interface PaddingStyle extends BaseStyle {
    type: 'PADDING'
    value: Padding
  }

  interface SpacingStyle extends BaseStyle {
    type: 'SPACING'
    value: Spacing
  }

  interface NumValue {
    value: number
    unit: 'PIXELS' | 'PERCENT'
  }

  interface TextSegStyle {
    start: number
    end: number
    textStyleId: string
    textStyle: {
      fontName: FontName
      localizedFontName: FontName
      referrer: FontReferrer
      fontSize: number
      letterSpacing: LetterSpacing
      lineHeight: LineHeight
      lineHeightByPx: number
      textDecoration: TextDecoration
      textCase: TextCase
      fontWeight: number
    }
    fills: Paint[]
    fillStyleId: string
  }

  interface ListStyle {
    start: number
    end: number
    level: number
    type: 'ORDERED' | 'BULLETED' | 'NONE'
  }

  interface EffectStyle extends BaseStyle {
    type: 'EFFECT'
    effects: ReadonlyArray<Effect>
  }

  interface TextStyle extends BaseStyle {
    type: 'TEXT'
    decoration: TextDecoration
    fontSize: number
    letterSpacing: number
    letterSpacingUnit: NumValue['unit']
    textCase: TextCase
    lineHeight: LineHeight
    fontName: FontName
  }

  interface FontAlias {
    title: string
    subtitle: string
  }

  interface GridStyle extends BaseStyle {
    type: 'GRID'
    layoutGrids: ReadonlyArray<LayoutGrid>
  }

  type Style =
    | PaintStyle
    | EffectStyle
    | TextStyle
    | GridStyle
    | StrokeWidthStyle
    | CornerRadiusStyle
    | PaddingStyle
    | SpacingStyle
    | Variable

  /// /////////////////////////////////////////////////////////////////////////////
  // Datatypes

  type Transform = [[number, number, number], [number, number, number]]

  interface TopContainerInfo {
    readonly id: string
    readonly name: string
    readonly transform: [number, number, number, number, number, number]
    readonly width: number
    readonly height: number
  }

  interface Vector {
    readonly x: number
    readonly y: number
  }

  interface RGB {
    readonly r: number
    readonly g: number
    readonly b: number
  }

  interface RGBA {
    readonly r: number
    readonly g: number
    readonly b: number
    readonly a: number
  }

  interface FontName {
    readonly family: string
    readonly style: string
  }

  type TextCase = 'ORIGINAL' | 'UPPER' | 'LOWER' | 'TITLE'

  type TextDecoration = 'NONE' | 'UNDERLINE' | 'STRIKETHROUGH'

  interface ShadowEffect {
    readonly type: 'DROP_SHADOW' | 'INNER_SHADOW'
    readonly color: RGBA
    // Effect的 x, y;
    readonly offset: Vector
    readonly spread: number
    readonly radius: number
    readonly isVisible: boolean
    readonly blendMode: BlendMode
    readonly showShadowBehindNode: boolean
    readonly isEffectShow: boolean
  }

  interface BlurEffect {
    readonly type: 'LAYER_BLUR' | 'BACKGROUND_BLUR'
    readonly radius: number
    readonly isVisible: boolean
    readonly blendMode: BlendMode
    readonly gradient: PluginGradientEffect
  }

  interface PluginGradientEffect {
    readonly mode: 'EVEN' | 'PROGRESSIVE'
    readonly gradientStops?: ReadonlyArray<PluginGradientStopItem>
    readonly gradientHandlePositions?: [Point, Point]
    readonly transform?: Transform
  }

  interface PluginGradientStopItem {
    readonly position: number
    readonly value: number
  }

  interface Point {
    readonly x: number
    readonly y: number
  }

  interface LiquidGlassEffect {
    readonly type: 'LIQUID_GLASS'
    readonly depth: number
    readonly dispersion: number
    readonly refraction: number
    readonly lightIntensity: number
    readonly lightAngle: number
    readonly isVisible: boolean
    readonly radius: number
    readonly blendMode: BlendMode
  }

  interface MotionBlurEffect {
    readonly type: 'MOTION_BLUR'
    readonly isVisible: boolean
    readonly radius: number
    readonly angle: number
    readonly blendMode: BlendMode
  }

  /**
   * 引用型特效：该 effect 引用了另一个特效样式（style 引用 style）。
   * 当团队库样式的某个 mode 引用了另一个特效样式时返回此类型，
   * 不携带具体特效值，仅保留引用信息。
   */
  interface ReferenceEffect {
    readonly type: 'REFERENCE'
    /** 被引用的样式 id */
    readonly reference: string
    /** 解析后的源样式 id（可能与 reference 相同） */
    readonly referenceSource?: string
    /** 所属模式 id */
    readonly modeId?: string
  }

  type Effect = ShadowEffect | BlurEffect | LiquidGlassEffect | MotionBlurEffect | ReferenceEffect

  // 待确认
  type ConstraintType = 'START' | 'END' | 'STARTANDEND' | 'CENTER' | 'SCALE'

  interface Constraints {
    readonly horizontal: ConstraintType
    readonly vertical: ConstraintType
  }

  interface ColorStop {
    readonly position: number
    readonly color: RGBA
  }

  interface SolidPaint {
    readonly type: 'SOLID'
    readonly color: RGBA

    readonly isVisible?: boolean
    /**
     * It always be 1 when type is 'SOLID', please modify the alpha field in color instead.
     * 纯色模式下alpha始终为1, 请设置color中的alpha.
     */
    readonly alpha?: number
    readonly blendMode?: BlendMode
    readonly name?: string
    readonly colorStyleId?: string
  }

  interface GradientPaint {
    readonly type:
      | 'GRADIENT_LINEAR'
      | 'GRADIENT_RADIAL'
      | 'GRADIENT_ANGULAR'
      | 'GRADIENT_DIAMOND'
    readonly transform: Transform
    readonly gradientStops: ReadonlyArray<ColorStop>
    readonly gradientHandlePositions?: [
      { x: number; y: number },
      { x: number; y: number }
    ]
    readonly isVisible?: boolean
    readonly alpha?: number
    readonly blendMode?: BlendMode
    readonly name?: string
    readonly colorStyleId?: string
  }

  interface ImageFilters {
    exposure?: number
    contrast?: number
    saturation?: number
    temperature?: number
    tint?: number
    highlights?: number
    shadows?: number
    hue?: number
  }

  interface ImagePaint {
    readonly type: 'IMAGE'
    readonly imageRef: string
    readonly scaleMode?: 'FILL' | 'TILE' | 'STRETCH' | 'FIT' | 'CROP'
    readonly filters?: ImageFilters

    readonly isVisible?: boolean
    readonly alpha?: number
    readonly blendMode?: BlendMode
    readonly name?: string
    readonly ratio?: number
    readonly rotation?: number
    readonly colorStyleId?: string
  }

  /**
   * 引用型填充：该 paint 引用了另一个填充样式（style 引用 style）。
   * 当团队库样式的某个 mode 引用了另一个填充样式时返回此类型，
   * 不携带具体填充值，仅保留引用信息。
   */
  interface ReferencePaint {
    readonly type: 'REFERENCE'
    /** 被引用的样式 id */
    readonly reference: string
    /** 解析后的源样式 id（可能与 reference 相同） */
    readonly referenceSource?: string
    /** 所属模式 id */
    readonly modeId?: string
  }

  type Paint = SolidPaint | GradientPaint | ImagePaint | ReferencePaint

  type CSSWidthSetter =
    | number
    | [number, number]
    | [number, number, number]
    | [number, number, number, number]

  interface StrokeWidth {
    width: CSSWidthSetter
  }

  interface Padding {
    padding: CSSWidthSetter
  }

  interface Spacing {
    spacing: CSSWidthSetter
  }

  interface CornerRadius {
    cornerRadius: CSSWidthSetter
  }

  type WindingRule = 'Nonzero' | 'Evenodd'

  // 待确定
  interface VectorVertex {
    readonly x: number
    readonly y: number
    readonly strokeCap?: StrokeCap
    readonly cornerRadius?: number
  }

  // 待确定
  interface VectorRegion {
    readonly windingRule: WindingRule
    readonly loops: ReadonlyArray<VectorPaths>
  }

  interface VectorCtrl {
    x: number
    y: number
  }

  type LetterSpacing = {
    readonly value: number
    readonly unit: 'PIXELS' | 'PERCENT'
  }

  type LineHeight =
    | {
        readonly value: number
        readonly unit: 'PIXELS' | 'PERCENT'
      }
    | {
        readonly unit: 'AUTO'
      }

  type BlendMode =
    | 'NORMAL'
    | 'DARKEN'
    | 'MULTIPLY'
    | 'COLOR_BURN'
    | 'LIGHTEN'
    | 'SCREEN'
    | 'COLOR_DODGE'
    | 'OVERLAY'
    | 'SOFT_LIGHT'
    | 'HARD_LIGHT'
    | 'DIFFERENCE'
    | 'EXCLUSION'
    | 'HUE'
    | 'SATURATION'
    | 'COLOR'
    | 'LUMINOSITY'
    | 'PLUS_DARKER'
    | 'PLUS_LIGHTER'
    | 'PASS_THROUGH'

  type FontReferrer = 'team' | 'org' | 'local' | 'official'

  interface Font {
    fontName: FontName
    localizedFontName: FontName
    referrer: FontReferrer
  }

  /// /////////////////////////////////////////////////////////////////////////////
  // Mixins

  interface BaseNodeMixin {
    readonly id: string
    readonly parent: (BaseNode & ChildrenMixin) | null
    name: string
    removed: boolean
    remove(): void
    getPluginData(key: string): string
    setPluginData(key: string, value: string): void
    getPluginDataKeys(): string[]
    removePluginData(key: string): void
    clearPluginData(): void
    getSharedPluginData(namespace: string, key: string): string
    setSharedPluginData(namespace: string, key: string, value: string): void
    getSharedPluginDataKeys(namespace: string): string[]
    removeSharedPluginData(namespace: string, key: string): void
    clearSharedPluginData(namespace: string): void
  }

  interface SceneNodeMixin {
    isVisible: boolean
    isLocked: boolean
    readonly attachedConnectors: ConnectorNode[]
    componentPropertyReferences: {
      isVisible?: string
      characters?: string
      mainComponent?: string
    } | null
    slotInfo: { slotName: string; slotAlias: string } | null
  }

  interface ChildrenMixin<ChildrenNode = SceneNode> {
    readonly children: ReadonlyArray<ChildrenNode>
    appendChild(child: SceneNode): void
    insertChild(index: number, child: SceneNode): void

    findChildren(
      callback?: (node: SceneNode) => boolean
    ): ReadonlyArray<SceneNode>
    findChild(callback: (node: SceneNode) => boolean): SceneNode | null

    findAll(callback?: (node: SceneNode) => boolean): ReadonlyArray<SceneNode>
    findOne(callback: (node: SceneNode) => boolean): SceneNode | null
    findAllWithCriteria<T extends NodeType[]>(criteria: {
      types: T
    }): Array<{ type: T[number] } & SceneNode>
  }

  interface ConstraintMixin {
    constraints: Constraints
  }

  interface Bound {
    x: number
    y: number
    width: number
    height: number
  }

  type ScaleCenter =
    | 'TOPLEFT'
    | 'TOP'
    | 'TOPRIGHT'
    | 'LEFT'
    | 'CENTER'
    | 'RIGHT'
    | 'BOTTOMLEFT'
    | 'BOTTOM'
    | 'BOTTOMRIGHT'

  interface ScaleOption {
    scaleCenter?: ScaleCenter
  }

  interface LayoutMixin {
    absoluteTransform: Transform
    relativeTransform: Transform
    readonly absoluteRenderBounds: Bound | null
    readonly absoluteBoundingBox: Bound
    bound: Bound
    x: number
    y: number
    width: number
    height: number
    minWidth: number | null
    maxWidth: number | null
    minHeight: number | null
    maxHeight: number | null
    rotation: number // In degrees
    constrainProportions: boolean
    layoutPositioning: 'AUTO' | 'ABSOLUTE' // applicable only inside auto-layout frames
    alignSelf: 'STRETCH' | 'INHERIT' // applicable only inside auto-layout frames
    flexGrow: 0 | 1 // applicable only inside auto-layout frames
    rescale(scale: number, scaleOption?: ScaleOption): void
    resize(width: number, height: number): void
    scaleFactor: number // The default value is 1
    flip(direction: 'VERTICAL' | 'HORIZONTAL'): void
  }

  interface BlendMixin {
    opacity: number
    blendMode: BlendMode
    isMask: boolean
    isMaskOutline: boolean
    isMaskVisible: boolean
    effects: ReadonlyArray<Effect>
    effectStyleId: string
  }

  type StrokeCap =
    | 'NONE'
    | 'ROUND'
    | 'SQUARE'
    | 'LINE_ARROW'
    | 'TRIANGLE_ARROW'
    | 'ROUND_ARROW'
    | 'RING'
    | 'DIAMOND'
    | 'LINE'
  type StrokeJoin = 'MITER' | 'BEVEL' | 'ROUND'
  type StrokeAlign = 'CENTER' | 'INSIDE' | 'OUTSIDE'
  type DashCap = 'NONE' | 'ROUND' | 'SQUARE'
  type StrokeStyle = 'SOLID' | 'DASH' | 'CUSTOM'
  type ConnectorStrokeCap = StrokeCap

  interface ConnectorEndpointPosition {
    readonly position: { x: number; y: number }
  }

  interface ConnectorEndpointConnected {
    readonly position: { x: number; y: number }
    readonly endpointNodeId: string
    readonly magnet: 'TOP' | 'LEFT' | 'BOTTOM' | 'RIGHT'
  }

  type ConnectorEndpoint =
    | ConnectorEndpointPosition
    | ConnectorEndpointConnected

  interface GeometryMixin {
    fills: ReadonlyArray<Paint>
    strokes: ReadonlyArray<Paint>
    strokeWeight: number
    strokeAlign: StrokeAlign
    strokeCap: StrokeCap
    strokeJoin: StrokeJoin
    strokeStyle: StrokeStyle
    dashCap: DashCap
    strokeDashes: ReadonlyArray<number>
    fillStyleId: string
    /**
     * @deprecated please use strokePaintStyleId instead
     */
    strokeStyleId: string
    strokeFillStyleId: string
    strokeWidthStyleId: string
    paddingStyleId: string
    spacingStyleId: string
    cornerRadiusStyleId: string

    /**
     * You have to ensure the layer has stroke before invoking this method.
     * 在调用接口之前需要确保layer有描边.
     */
    outlineStroke(): SceneNode | null
  }

  interface RectangleStrokeWeightMixin {
    strokeTopWeight: number
    strokeLeftWeight: number
    strokeBottomWeight: number
    strokeRightWeight: number
  }

  interface CornerMixin {
    cornerSmooth: number
    cornerRadius: number | PluginAPI['mixed']

    topLeftRadius: number
    topRightRadius: number
    bottomLeftRadius: number
    bottomRightRadius: number
  }

  interface DefaultShapeMixin
    extends BaseNodeMixin,
      SceneNodeMixin,
      BlendMixin,
      GeometryMixin,
      LayoutMixin,
      ReactionMixin,
      ExportMixin {}

  interface DefaultContainerMixin
    extends BaseNodeMixin,
      ContainerMixin,
      ReactionMixin,
      SceneNodeMixin,
      ChildrenMixin,
      BlendMixin,
      CornerMixin,
      ConstraintMixin,
      LayoutMixin,
      ExportMixin {}
  interface ContainerMixin {
    expanded: boolean
  }
  interface AutoLayout {
    flexMode: 'NONE' | 'HORIZONTAL' | 'VERTICAL'
    flexWrap: 'WRAP' | 'NO_WRAP'
    itemSpacing: number
    mainAxisAlignItems: 'FLEX_START' | 'FLEX_END' | 'CENTER' | 'SPACING_BETWEEN'
    crossAxisAlignItems: 'FLEX_START' | 'FLEX_END' | 'CENTER'
    mainAxisSizingMode: 'FIXED' | 'AUTO'
    crossAxisSizingMode: 'FIXED' | 'AUTO'
    crossAxisAlignContent: 'AUTO' | 'SPACE_BETWEEN'
    crossAxisSpacing: number | null
    strokesIncludedInLayout: boolean
    itemReverseZIndex: boolean
    paddingTop: number
    paddingRight: number
    paddingBottom: number
    paddingLeft: number
  }

  interface RowsColsLayoutGrid {
    readonly gridType: 'ROWS' | 'COLUMNS'

    readonly alignment: 'LEFT' | 'RIGHT' | 'STRETCH' | 'CENTER'
    readonly gutterSize: number
    readonly count: number
    readonly sectionSize?: number | null
    readonly offset?: number

    readonly isVisible?: boolean
    readonly color?: RGBA
    readonly id?: string
    readonly name?: string
  }

  interface GridLayoutGrid {
    readonly gridType: 'GRID'

    readonly sectionSize: number

    readonly isVisible?: boolean
    readonly color?: RGBA
    readonly id?: string
    readonly name?: string
  }

  type LayoutGrid = RowsColsLayoutGrid | GridLayoutGrid

  interface FrameContainerMixin extends AutoLayout {
    clipsContent: boolean
    layoutGrids: ReadonlyArray<LayoutGrid>
    gridStyleId: string
    overflowDirection: OverflowDirection
  }

  type OverflowDirection = 'NONE' | 'HORIZONTAL' | 'VERTICAL' | 'BOTH'

  interface ReactionMixin {
    reactions: ReadonlyArray<Reaction>
  }

  interface OpaqueNodeMixin extends BaseNodeMixin, SceneNodeMixin, ExportMixin {
    readonly absoluteTransform: Transform
    readonly relativeTransform: Transform
    readonly absoluteRenderBounds: Bound | null
    readonly absoluteBoundingBox: Bound
    x: number
    y: number
    readonly width: number
    readonly height: number
    readonly bound: Bound
  }

  interface MinimalBlendMixin {
    opacity: number
    blendMode: BlendMode
  }

  interface MinimalStrokesMixin {
    strokes: ReadonlyArray<Paint>
    strokeStyleId: string
    strokeWeight: number
    strokeJoin: StrokeJoin
    strokeAlign: StrokeAlign
    strokeStyle: StrokeStyle
    strokeCap: StrokeCap
    strokeDashes: ReadonlyArray<number>
    dashCap: DashCap
  }

  interface MinimalFillsMixin {
    fills: ReadonlyArray<Paint>
    fillStyleId: string
  }

  /// /////////////////////////////////////////////////////////////////////////////
  // Nodes

  interface DocumentNode {
    readonly type: 'DOCUMENT'

    readonly id: string
    name: string

    currentPage: PageNode

    readonly children: ReadonlyArray<PageNode>

    findAll(callback?: (node: SceneNode) => boolean): ReadonlyArray<SceneNode>
    findOne(callback: (node: SceneNode) => boolean): SceneNode | null
    findAllWithCriteria<T extends NodeType[]>(criteria: {
      types: T
    }): Array<{ type: T[number] } & SceneNode>
  }

  interface PageNode extends ChildrenMixin<SceneNode> {
    readonly type: 'PAGE'

    readonly id: string
    readonly parent: DocumentNode
    name: string
    removed: boolean
    remove(): void

    selection: ReadonlyArray<SceneNode>
    clone(): PageNode
    /**
     * 选中所有图层
     */
    selectAll(): void
    /**
     * 背景颜色
     */
    bgColor: RGBA
    /**
     * 获取当前页面的所有导出项
     */
    getExportList(): ReadonlyArray<PageExportItem>
    /**
     * 原型所有的flow
     */
    readonly flowStartingPoints: FlowStartingPoint[]
    /**
     * 标签,默认'NONE'
     */
    label: 'NONE' | 'BLUE' | 'GREEN' | 'RED' | 'YELLOW' | 'PURPLE' | 'GRAY'
  }

  interface SectionNode
    extends Omit<
        DefaultContainerMixin,
        | 'opacity'
        | 'blendMode'
        | 'isMask'
        | 'isMaskOutline'
        | 'isMaskVisible'
        | 'effects'
        | 'effectStyleId'
      >,
      GeometryMixin,
      FrameContainerMixin,
      RectangleStrokeWeightMixin {
    readonly type: 'SECTION'
    clone(): SectionNode
  }

  interface FrameNode
    extends DefaultContainerMixin,
      GeometryMixin,
      FrameContainerMixin,
      RectangleStrokeWeightMixin {
    readonly type: 'FRAME'
    clone(): FrameNode
    resizeToFit(): void
  }

  interface IntelligentContainerNode
    extends DefaultContainerMixin,
      GeometryMixin,
      FrameContainerMixin,
      RectangleStrokeWeightMixin {
    readonly type: 'INTELLIGENT_CONTAINER'
    clone(): IntelligentContainerNode
    resizeToFit(): void
    shaderCode: string
    isPlaying: boolean
  }

  interface RectangleNode
    extends DefaultShapeMixin,
      ConstraintMixin,
      CornerMixin,
      RectangleStrokeWeightMixin {
    readonly type: 'RECTANGLE'
    clone(): RectangleNode
  }

  interface LineNode extends DefaultShapeMixin, ConstraintMixin {
    readonly type: 'LINE'
    clone(): LineNode
    readonly height: number
    leftStrokeCap: StrokeCap
    rightStrokeCap: StrokeCap
  }

  interface EllipseNode extends DefaultShapeMixin, ConstraintMixin {
    readonly type: 'ELLIPSE'
    clone(): EllipseNode
    arcData: ArcData
  }

  interface PolygonNode
    extends DefaultShapeMixin,
      ConstraintMixin,
      CornerMixin {
    readonly type: 'POLYGON'
    pointCount: number
    clone(): PolygonNode
  }

  interface StarNode extends DefaultShapeMixin, ConstraintMixin, CornerMixin {
    readonly type: 'STAR'
    pointCount: number
    innerRadius: number
    clone(): StarNode
  }

  type VectorPaths = ReadonlyArray<number>
  type VectorPath = [number, number, number, number]

  interface PenNetwork {
    paths: ReadonlyArray<VectorPath>
    nodes: ReadonlyArray<VectorVertex>
    regions: ReadonlyArray<VectorRegion>
    ctrlNodes: ReadonlyArray<VectorCtrl>
  }

  interface PenPaths {
    windingRule: WindingRule
    data: string
  }

  interface PenNode extends DefaultShapeMixin, ConstraintMixin, CornerMixin {
    readonly type: 'PEN'
    penNetwork: PenNetwork
    set penPaths(paths: Array<PenPaths>)
    //@ts-ignore
    get penPaths(): PenPaths
    clone(): PenNode
  }

  interface BooleanOperationNode
    extends DefaultShapeMixin,
      ContainerMixin,
      ChildrenMixin,
      CornerMixin {
    readonly type: 'BOOLEAN_OPERATION'
    booleanOperation: 'UNION' | 'INTERSECT' | 'SUBTRACT' | 'EXCLUDE'
    clone(): BooleanOperationNode
  }

  interface GroupNode
    extends DefaultShapeMixin,
      ContainerMixin,
      ChildrenMixin,
      CornerMixin {
    readonly type: 'GROUP'
    clone(): GroupNode
  }

  interface TextRangeStyle {
    fontName: FontName
    fontSize: number
    lineHeight: LineHeight
    textDecoration: TextDecoration
    letterSpacing: LetterSpacing
  }

  enum LinkFlagEnum {
    CURRPAGE = 'currPage',
    OTHERPAGE = 'otherPage',
    PROTOTYPE = 'prototype',
    OUTFILE = 'outFile',
    OWNWEBSITE = 'ownWebsite',
    OTHERLINK = 'otherLink'
  }

  interface Superlink {
    start: number
    end: number
    superlink: {
      layerId?: string
      link: string
      linkFlag: LinkFlagEnum
      pageId: string
    }
  }

  interface Hyperlink {
    type: 'PAGE' | 'NODE' | 'URL'
    value: string
  }
  interface HyperlinkWithRange {
    start: number
    end: number
    hyperlink: Hyperlink
  }

  interface TextNode extends DefaultShapeMixin, ConstraintMixin {
    readonly type: 'TEXT'
    characters: string
    readonly hasMissingFont: boolean
    /**
     * @deprecated
     * This attribute is deprecated, please use hyperlinks instead.
     */
    readonly superlinks: Array<Superlink>
    readonly hyperlinks: Array<HyperlinkWithRange>
    textAlignHorizontal: 'LEFT' | 'CENTER' | 'RIGHT' | 'JUSTIFIED'
    textAlignVertical: 'TOP' | 'CENTER' | 'BOTTOM'
    textAutoResize: 'NONE' | 'WIDTH_AND_HEIGHT' | 'HEIGHT' | 'TRUNCATE' | 'TRUNCATE_AND_AUTO_WIDTH' | 'TRUNCATE_AND_AUTO_HEIGHT'
    paragraphSpacing: number
    /**
     * 文字样式 ID。
     * 传空字符串可解除引用；传入非法的样式 ID 会抛出异常。
     */
    textStyleId: string
    /**
     * 文本内容绑定的变量/样式引用 ID，未绑定时为空字符串。
     * 优先按图层 id 读取引擎真值，不依赖图层的选中状态。
     * 绑定请使用 setVariableReferenceInLayer 的 textProperty: 'textContent'。
     */
    readonly textContentStyleId: string
    readonly textStyles: ReadonlyArray<TextSegStyle>
    readonly listStyles: ReadonlyArray<ListStyle>
    clone(): TextNode

    insertCharacters(start: number, characters: string): void
    deleteCharacters(start: number, end: number): void

    setRangeFontSize(start: number, end: number, fontSize: number): void
    setRangeTextDecoration(
      start: number,
      end: number,
      decoration: TextDecoration
    ): void
    setRangeFontName(start: number, end: number, fontName: FontName): void
    setRangeLetterSpacing(
      start: number,
      end: number,
      value: LetterSpacing
    ): void
    setRangeLineHeight(start: number, end: number, value: LineHeight): void
    setRangeFills(start: number, end: number, paints: Paint[]): void
    /**
     * @deprecated
     * This function is deprecated, please use setRangeHyperlink instead.
     */
    setRangeSuperLink(start: number, end: number, link: string | null): void
    setRangeHyperlink(
      start: number,
      end: number,
      hyperlink: Hyperlink | null
    ): void
    setRangeTextCase(start: number, end: number, textCase: TextCase): void
    setRangeListStyle(
      start: number,
      end: number,
      type: 'ORDERED' | 'BULLETED' | 'NONE'
    ): void

    setRangeFillStyleId(start: number, end: number, fillStyleId: string): void
    setRangeTextStyleId(start: number, end: number, textStyleId: string): void
  }

  type VariantMixin = {
    property: string
    type: 'variant'
    values: string[]
  }

  interface VariantProperty {
    property: string
    value: string
    componentSetProperAlias?: string
    alias?: string
  }

  interface ComponentPropertiesMixin {
    readonly componentPropertyValues: ComponentPropertyValues
    addComponentProperty(
      propertyName: string,
      type: Exclude<ComponentPropertyType, 'VARIANT'>,
      defaultValue: string | boolean,
      options?: ComponentPropertyOptions
    ): string
    editComponentProperty(
      propertyId: string,
      newValue: {
        name?: string
        defaultValue?: string | boolean
        preferredValues?: InstanceSwapPreferredValue[]
        alias?: string
      }
    ): string
    deleteComponentProperty(propertyId: string): void
  }

  type ComponentPropertyValues = Array<ComponentPropertyValue>

  type ComponentPropertyValue = {
    name: string
    type: ComponentPropertyType
    defaultValue: string | boolean
    id?: string
    variantOptions?: string[]
    preferredValues?: InstanceSwapPreferredValue[]
    alias?: string
    /**
     * 变体属性的可选值别名数组，仅当 type 为 VARIANT 时存在。
     * 已剥离内部默认值标记（如 `$default`），元素可能为空字符串。
     */
    variantOptionsAlias?: string[]
    /** 当组件属性绑定到变量时，对应的变量 id（仅 TEXT/BOOLEAN 类型可能存在） */
    variableId?: string
  }

  type ComponentPropertyType = 'BOOLEAN' | 'TEXT' | 'INSTANCE_SWAP' | 'VARIANT'
  type InstanceSwapPreferredValue = {
    type: 'COMPONENT' | 'COMPONENT_SET'
    key: string
  }
  type ComponentPropertyOptions = {
    preferredValues?: InstanceSwapPreferredValue[]
  }
  type ComponentItemVal = {
    id: string
    name: string
    componentSignature: string
    cover: string
    description: string
    documentationLinks: Array<{ url: string }>
    height: number
    width: number
    isExternal: boolean
    isHidden: boolean
    pageId: string
    pageName: string
    ukey: string
    version: number
    componentNameAlias: string
    parentId?: string
  }
  type ComponentProperties = {
    name: string
    id?: string
    type: ComponentPropertyType
    value: boolean | string
    preferredValues?: InstanceSwapPreferredValue[]
    alias?: string
    /**
     * 当前变体属性取值的别名，仅当 type 为 VARIANT 时存在。
     * 已剥离内部默认值标记（如 `$default`），可能为空字符串。
     */
    valueAlias?: string
    /**
     * 当前变体取值是否为该属性的默认值，仅当 type 为 VARIANT 时存在。
     */
    isDefaultValue?: boolean
  }

  interface ComponentNode
    extends DefaultContainerMixin,
      GeometryMixin,
      FrameContainerMixin,
      RectangleStrokeWeightMixin,
      PublishableMixin,
      ComponentPropertiesMixin {
    readonly type: 'COMPONENT'
    readonly variantProperties: Array<VariantProperty> | undefined
    setVariantPropertyValues(property: Record<string, string>): void
    clone(): InstanceNode
    createInstance(): InstanceNode
    resizeToFit(): void
  }

  interface ComponentSetNode
    extends Omit<DefaultContainerMixin, 'appendChild' | 'insertChild'>,
      GeometryMixin,
      FrameContainerMixin,
      RectangleStrokeWeightMixin,
      PublishableMixin,
      ComponentPropertiesMixin {
    readonly type: 'COMPONENT_SET'
    clone(): ComponentSetNode
    createVariantComponent(): void
    createVariantProperties(properties: Array<string>): void
    editVariantProperties(properties: Record<string, string>): void
    editVariantPropertyValues(
      properties: Record<string, { oldValue: string; newValue: string }>
    ): void
    editVariantPropertiesAlias(properties: Record<string, string>): void
    editVariantPropertyValuesAlias(
      properties: Record<string, { name: string; alias: string }>
    ): void
    deleteVariantProperty(property: string): void
    resizeToFit(): void
  }

  interface InstanceNode
    extends Omit<DefaultContainerMixin, 'appendChild' | 'insertChild'>,
      GeometryMixin,
      FrameContainerMixin,
      RectangleStrokeWeightMixin {
    readonly type: 'INSTANCE'
    readonly variantProperties: Array<VariantProperty> | undefined

    setVariantPropertyValues(property: Record<string, string>): void

    readonly componentProperties: Array<ComponentProperties>
    setProperties(properties: { [propertyId: string]: string | boolean }): void
    readonly exposedInstances: InstanceNode[]
    isExposedInstance: boolean

    resetOverrides(): void

    clone(): InstanceNode
    /**
     * this is an async func
     */
    swapComponent(component: ComponentNode): void
    detachInstance(): FrameNode
    mainComponent: ComponentNode | null
  }

  interface SliceNode
    extends BaseNodeMixin,
      LayoutMixin,
      ConstraintMixin,
      SceneNodeMixin,
      ExportMixin {
    readonly type: 'SLICE'
    clone(): SliceNode
    isPreserveRatio: boolean
  }

  interface ConnectorNode
    extends OpaqueNodeMixin,
      Pick<MinimalBlendMixin, 'opacity'>,
      Omit<MinimalStrokesMixin, 'strokeAlign'> {
    readonly type: 'CONNECTOR'
    createText(): TextSublayerNode
    readonly text: TextSublayerNode | null
    cornerRadius?: number
    connectorStart: ConnectorEndpoint
    connectorEnd: ConnectorEndpoint
    connectorStartStrokeCap: ConnectorStrokeCap
    connectorEndStrokeCap: ConnectorStrokeCap
    readonly strokeAlign: 'CENTER'
    clone(): ConnectorNode
  }

  interface TextSublayerNode extends MinimalFillsMixin {
    readonly id: string
    readonly hasMissingFont: boolean
    readonly textAlignHorizontal: 'CENTER'
    readonly textAlignVertical: 'CENTER'
    readonly textAutoResize: 'WIDTH_AND_HEIGHT'
    readonly hyperlinks: Array<HyperlinkWithRange>

    readonly textStyles: ReadonlyArray<TextSegStyle>

    paragraphSpacing: number

    characters: string
    insertCharacters(start: number, characters: string): void
    deleteCharacters(start: number, end: number): void

    setRangeFontSize(start: number, end: number, fontSize: number): void
    setRangeTextDecoration(
      start: number,
      end: number,
      decoration: TextDecoration
    ): void
    setRangeFontName(start: number, end: number, fontName: FontName): void
    setRangeLetterSpacing(
      start: number,
      end: number,
      value: LetterSpacing
    ): void
    setRangeLineHeight(start: number, end: number, value: LineHeight): void
    setRangeFills(start: number, end: number, paints: Paint[]): void
    setRangeHyperlink(
      start: number,
      end: number,
      hyperlink: Hyperlink | null
    ): void
    setRangeTextCase(start: number, end: number, textCase: TextCase): void

    setRangeListStyle(
      start: number,
      end: number,
      type: 'ORDERED' | 'BULLETED' | 'NONE'
    ): void

    setRangeFillStyleId(start: number, end: number, fillStyleId: string): void
    setRangeTextStyleId(start: number, end: number, textStyleId: string): void
  }

  interface CreateStyleConfig {
    name: string
    /**
     * layerId
     */
    id: string
    description?: string
    collectionId?: string
  }

  interface FlowStartingPoint {
    name: string
    id: string
    flowId: string
    description: string
  }
  interface Reaction {
    readonly trigger: Trigger
    readonly action?: Action
  }
  interface Action {
    readonly type: ActionType
    readonly destinationId: string
    readonly navigation: Navigation
    readonly transition: Transition
    readonly url: string
    readonly scrollToXOffset?: number
    readonly scrollToYOffset?: number
  }

  type ActionType = 'BACK' | 'NODE' | 'URL' | 'CLOSE' | 'NONE'

  type Navigation = 'NAVIGATE' | 'OVERLAY' | 'SWAP_OVERLAY' | 'SCROLL_TO'

  interface Transition {
    readonly type: TransitionType
    readonly duration: number
    readonly direction: TransitionDirection
    readonly easing: Easing
  }

  type TransitionType =
    | 'TANS_NONE'
    | 'INSTANT'
    | 'DISSOLVE'
    | 'SMART_ANIMATE'
    | 'MOVE_IN'
    | 'MOVE_OUT'
    | 'PUSH'
    | 'SLIDE_IN'
    | 'SLIDE_OUT'
    | 'DISPLACE'

  type TransitionDirection = 'LEFT' | 'RIGHT' | 'TOP' | 'BOTTOM'
  interface Easing {
    readonly type: EasingType
    readonly easingFunctionCubicBezier: {
      x1: number
      x2: number
      y1: number
      y2: number
    }
  }

  type EasingType =
    | 'LINEAR'
    | 'EASE_IN'
    | 'EASE_OUT'
    | 'EASE_IN_AND_OUT'
    | 'EASE_IN_BACK'
    | 'EASE_OUT_BACK'
    | 'EASE_IN_AND_OUT_BACK'
    | 'CUSTOM_CUBIC_BEZIER'
  interface Trigger {
    readonly type: TriggerType
    readonly delay: number
  }
  type TriggerType =
    | 'ON_CLICK'
    | 'ON_DRAG'
    | 'ON_HOVER'
    | 'ON_PRESS'
    | 'MOUSE_ENTER'
    | 'MOUSE_LEAVE'
    | 'MOUSE_DOWN'
    | 'MOUSE_UP'
    | 'AFTER_DELAY'

  interface ArcData {
    /**
     * 起点弧度
     */
    startingAngle: number
    /**
     * 终点弧度
     */
    endingAngle?: number
    /**
     * 内径
     */
    innerRadius: number
  }

  interface PluginDrop {
    clientX: number
    clientY: number
    dropMetadata?: any
  }

  interface DropEvent {
    x: number
    y: number
    absoluteX: number
    absoluteY: number
    dropMetadata?: any
  }

  interface TeamLibraryComponent {
    readonly id: string
    readonly name: string
    readonly ukey: string
    readonly description: string
    readonly type: 'COMPONENT' | 'COMPONENT_SET'
    readonly cover: string
    readonly width: number
    readonly height: number
    /** 如果 Component 属于某一个 ComponentSet，则 componentSetUkey 为 ComponentSet 的 ukey, 否则为空字符串 */
    readonly componentSetUkey: string
    /** 组件所在容器的名称；未设置时可能缺省 */
    readonly frameName?: string
    /** 组件属性 / 变体属性，对齐 ComponentPropertyValue 结构；老库（该字段上线前发布的）可能缺省 */
    readonly properties?: ComponentPropertyValue[]
    /** 组件所有后代 TEXT 图层的名称（去重）；老库可能缺省 */
    readonly textNodeNames?: string[]
  }

  interface TeamLibraryStyle {
    readonly id: string
    readonly name: string
    readonly ukey: string
    readonly description: string
    readonly type: StyleType
    /** 变量所属集合的 id，仅在变量类型（color/number/string/bool）上存在 */
    readonly collectionId?: string
    /** 变量所属集合的名称 */
    readonly collectionName?: string
    /**
     * 各模式下的样式值列表，元素结构为 { modeId, modeName, value }。
     *
     * value 形态随 style 类型变化：
     * - paints / colors: Paint[]（colors 由变量化颜色的 floatData[r,g,b,a] 转换得到）
     * - effects: Effect[]
     * - texts: 文本样式对象数组
     * - grids: LayoutGrid[]
     * - strokeWidths / numbers / spacings / paddings / cornerRadiuses: number[]
     * - strings: string
     * - bools: boolean
     *
     * 变量引用项（reference 且样式为变量化）或解析异常时，该 mode 项仍保留，但 value 为 undefined。
     * 老库（该字段上线前发布的）可能缺省此字段。
     */
    readonly values?: ReadonlyArray<TeamLibraryStyleValue>
    /** 代码语法（web/android/ios），来自发布时 cover.codeSyntax；老库（该字段上线前发布的）可能缺省 */
    readonly codeSyntax?: VariableCodeSyntax
  }

  /**
   * TeamLibraryStyle.values 数组中的单个元素。
   */
  interface TeamLibraryStyleValue {
    readonly modeId: string
    readonly modeName: string
    /**
     * 该模式下的样式值，形态随 style 类型变化，详见 TeamLibraryStyle.values 注释。
     * 变量引用或解析异常时为 undefined。
     */
    readonly value: any
  }

  interface TeamLibraryItem {
    readonly name: string
    readonly id: string
    readonly componentList: TeamLibraryComponent[]
    readonly style: {
      paints: ReadonlyArray<TeamLibraryStyle>
      effects: ReadonlyArray<TeamLibraryStyle>
      texts: ReadonlyArray<TeamLibraryStyle>
      grids: ReadonlyArray<TeamLibraryStyle>
      strokeWidths: ReadonlyArray<TeamLibraryStyle>
      cornerRadiuses: ReadonlyArray<TeamLibraryStyle>
      paddings: ReadonlyArray<TeamLibraryStyle>
      spacings: ReadonlyArray<TeamLibraryStyle>
      numbers: ReadonlyArray<TeamLibraryStyle>
      strings: ReadonlyArray<TeamLibraryStyle>
      bools: ReadonlyArray<TeamLibraryStyle>
      colors: ReadonlyArray<TeamLibraryStyle>
    }
  }

  type TeamLibrary = ReadonlyArray<TeamLibraryItem>

  interface PublishedTeamLibraryCollection {
    readonly id: string
    readonly name: string
    readonly key?: string
    readonly modes: ReadonlyArray<{
      readonly id: string
      readonly name: string
    }>
  }

  interface PublishedTeamLibrary extends TeamLibraryItem {
    /** 团队库 ID */
    readonly id: string
    /** 团队库版本 */
    readonly version?: number
    /** 所属企业 ID */
    readonly organizationId?: string | number
    /** 所属团队 ID */
    readonly teamId?: string | number
    /** 团队库类型 */
    readonly teamLibType?: string | number
    /** 研发模式相关配置 */
    readonly dsmSettings?: {
      readonly frameworkType?: string
      readonly componentTemplate?: string
    }
    readonly collections: ReadonlyArray<PublishedTeamLibraryCollection>
  }

  type BaseNode = DocumentNode | PageNode | SceneNode

  /**
   * 画布节点
   */
  type SceneNode =
    | GroupNode
    | FrameNode
    | PenNode
    | StarNode
    | LineNode
    | EllipseNode
    | PolygonNode
    | RectangleNode
    | TextNode
    | ComponentNode
    | ComponentSetNode
    | InstanceNode
    | BooleanOperationNode
    | SliceNode
    | ConnectorNode
    | SectionNode
    | IntelligentContainerNode

  type NodeType =
    | 'DOCUMENT'
    | 'PAGE'
    | 'GROUP'
    | 'FRAME'
    | 'RECTANGLE'
    | 'TEXT'
    | 'LINE'
    | 'ELLIPSE'
    | 'POLYGON'
    | 'STAR'
    | 'PEN'
    | 'COMPONENT'
    | 'COMPONENT_SET'
    | 'INSTANCE'
    | 'BOOLEAN_OPERATION'
    | 'SLICE'
    | 'CONNECTOR'
    | 'SECTION'
    | 'INTELLIGENT_CONTAINER'

  // d2c
  type CodeFile = {
    /**
     * import third-party paths
     */
    importPath?: {
      name: string
      path: string
      type: 'script' | 'style'
    }[]
    importType?: 'GLOBAL' | 'IMPORT'
    // absolute path
    path: string
    // relative to the relative path of the imported file
    relativePath: string
    fileName: string
    type:
      | 'css'
      | 'js'
      | 'typescript'
      | 'ts-definition'
      | 'static'
      | 'vue'
      | 'react'
      | 'java'
      | 'kt'
      | 'xml'
    // code
    code: string
    // parsed code
    parsedCode?: string
    // import
    chunks?: CodeFile[]
  }
  interface CodegenAPI {
    /**
     * @param event a callback function that is triggered when the plugin generates the DSL, and the parameter of the callback function is the modified DSL data
     */
    on(
      type: 'generateDSL',
      event: (generateData: {
        data: MGDSL.MGDSLData
        callback: (modifiedData: MGDSL.MGDSLData) => void
      }) => void
    ): void
    /**
     * @param event a callback function that is triggered when the plugin generates the DSL, and the parameter of the callback function is the custom code, and when the callback returns the custom code, the custom code will be used as the standard, and the code will not be generated according to the DSL
     */
    on(
      type: 'generate',
      event: (generateData: {
        data: MGDSL.MGDSLData
        callback: (modifiedData: MGDSL.CustomCode) => void
      }) => void
    ): void
    /**
     * @param event a callback function that is triggered when the plugin generates the code, and the parameter of the callback function is the generated code
     */
    on(
      type: 'codeChange',
      event: (data: MGDSL.CustomCode['data']) => void
    ): void
    /**
     * Set the component template
     * @description used to set the component mapping relationship
     * @param template component template
     */
    setComponentTemplate(template: MGTMP.ComponentTemplate): void
    /**
     * Get code by id and framework
     * @param layerId layer id
     * @param type framework type
     * @returns code file
     */
    getCode(layerId: string, type: MGDSL.Framework): Promise<CodeFile | null>
    /**
     * Get DSL by id and framework
     * @param layerId layer id
     * @param type framework type
     * @returns DSL data
     */
    getDSL(
      layerId: string,
      type: MGDSL.Framework
    ): Promise<MGDSL.MGDSLData | null>
    /**
     * Get code by DSL
     * @param data DSL data
     * @param type framework type
     * @returns code file
     */
    getCodeByDSL(
      data: MGDSL.MGDSLData,
      type: MGDSL.Framework
    ): Promise<CodeFile | null>
  }

  interface SnippetgenData {
    language: string
    layerId: string
    preferences: Record<string, string>
    unit: Record<string, string>
  }

  interface SnippetGenResult {
    language: string
    code: string
    title: string
  }

  interface SnippetgenAPI {
    on(
      type: 'generate',
      event: (
        data: SnippetgenData,
        callback: (modifiedData: SnippetGenResult[]) => void
      ) => void
    ): void
    off(
      type: 'generate',
      event: (
        data: SnippetgenData,
        callback: (modifiedData: SnippetGenResult[]) => void
      ) => void
    ): void

    on(type: 'action', event: (value: string) => void): void
    off(type: 'action', event: (value: string) => void): void
  }

  type StyleReturnType<T extends StyleType> = T extends 'PAINT'
    ? PaintStyle
    : T extends 'TEXT'
    ? TextStyle
    : T extends 'EFFECT'
    ? EffectStyle
    : T extends 'GRID'
    ? GridStyle
    : T extends 'STROKE_WIDTH'
    ? StrokeWidthStyle
    : T extends 'CORNER_RADIUS'
    ? CornerRadiusStyle
    : T extends 'PADDING'
    ? PaddingStyle
    : T extends 'SPACING'
    ? SpacingStyle
    : never

  type NodeStyleReturnType<T extends NodeStyleType> = T extends 'fill'
    ? PaintStyle
    : T extends 'strokeFill'
    ? PaintStyle
    : T extends 'strokeWidth'
    ? StrokeWidthStyle
    : T extends 'cornerRadius'
    ? CornerRadiusStyle
    : T extends 'padding'
    ? PaddingStyle
    : T extends 'spacing'
    ? SpacingStyle
    : T extends 'effect'
    ? EffectStyle
    : T extends 'text'
    ? TextStyle
    : T extends 'grid'
    ? GridStyle
    : never
}

export {}