figma.d.ts

// https://www.figma.com/plugin-docs/api/typings/
// Figma Plugin API version 1, update 14

declare global {
// Global variable with Figma's plugin API.
const figma: PluginAPI
const __html__: string

interface PluginAPI {
  readonly apiVersion: "1.0.0"
  readonly command: string
  readonly viewport: ViewportAPI
  closePlugin(message?: string): void

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

  showUI(html: string, options?: ShowUIOptions): void
  readonly ui: UIAPI

  readonly clientStorage: ClientStorageAPI

  getNodeById(id: string): BaseNode | null
  getStyleById(id: string): BaseStyle | null

  readonly root: DocumentNode
  currentPage: PageNode

  on(type: "selectionchange" | "currentpagechange" | "close", callback: () => void): void
  once(type: "selectionchange" | "currentpagechange" | "close", callback: () => void): void
  off(type: "selectionchange" | "currentpagechange" | "close", callback: () => void): void

  readonly mixed: unique symbol

  createRectangle(): RectangleNode
  createLine(): LineNode
  createEllipse(): EllipseNode
  createPolygon(): PolygonNode
  createStar(): StarNode
  createVector(): VectorNode
  createText(): TextNode
  createFrame(): FrameNode
  createComponent(): ComponentNode
  createPage(): PageNode
  createSlice(): SliceNode
  /**
   * [DEPRECATED]: This API often fails to create a valid boolean operation. Use figma.union, figma.subtract, figma.intersect and figma.exclude instead.
   */
  createBooleanOperation(): BooleanOperationNode

  createPaintStyle(): PaintStyle
  createTextStyle(): TextStyle
  createEffectStyle(): EffectStyle
  createGridStyle(): GridStyle

  // The styles are returned in the same order as displayed in the UI. Only
  // local styles are returned. Never styles from team library.
  getLocalPaintStyles(): PaintStyle[]
  getLocalTextStyles(): TextStyle[]
  getLocalEffectStyles(): EffectStyle[]
  getLocalGridStyles(): GridStyle[]

  importComponentByKeyAsync(key: string): Promise<ComponentNode>
  importStyleByKeyAsync(key: string): Promise<BaseStyle>

  listAvailableFontsAsync(): Promise<Font[]>
  loadFontAsync(fontName: FontName): Promise<void>
  readonly hasMissingFont: boolean

  createNodeFromSvg(svg: string): FrameNode

  createImage(data: Uint8Array): Image
  getImageByHash(hash: string): Image

  group(nodes: ReadonlyArray<BaseNode>, parent: BaseNode & ChildrenMixin, index?: number): GroupNode
  flatten(nodes: ReadonlyArray<BaseNode>, parent?: BaseNode & ChildrenMixin, index?: number): VectorNode

  union(nodes: ReadonlyArray<BaseNode>, parent: BaseNode & ChildrenMixin, index?: number): BooleanOperationNode
  subtract(nodes: ReadonlyArray<BaseNode>, parent: BaseNode & ChildrenMixin, index?: number): BooleanOperationNode
  intersect(nodes: ReadonlyArray<BaseNode>, parent: BaseNode & ChildrenMixin, index?: number): BooleanOperationNode
  exclude(nodes: ReadonlyArray<BaseNode>, parent: BaseNode & ChildrenMixin, index?: number): BooleanOperationNode
}

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

interface NotificationOptions {
  timeout?: number
}

interface NotificationHandler {
  cancel: () => void
}

interface ShowUIOptions {
  visible?: boolean
  width?: number
  height?: number
}

interface UIPostMessageOptions {
  origin?: string
}

interface OnMessageProperties {
  origin: string
}

type MessageEventHandler = (pluginMessage: any, props: OnMessageProperties) => void

interface UIAPI {
  show(): void
  hide(): void
  resize(width: number, height: number): void
  close(): void

  postMessage(pluginMessage: any, options?: UIPostMessageOptions): void
  onmessage: MessageEventHandler | undefined
  on(type: "message", callback: MessageEventHandler): void
  once(type: "message", callback: MessageEventHandler): void
  off(type: "message", callback: MessageEventHandler): void
}

interface ViewportAPI {
  center: Vector
  zoom: number
  scrollAndZoomIntoView(nodes: ReadonlyArray<BaseNode>): void
  readonly bounds: Rect
}

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

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

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

interface Rect {
  readonly x: number
  readonly y: number
  readonly width: number
  readonly height: 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 ArcData {
  readonly startingAngle: number
  readonly endingAngle: number
  readonly innerRadius: number
}

interface ShadowEffect {
  readonly type: "DROP_SHADOW" | "INNER_SHADOW"
  readonly color: RGBA
  readonly offset: Vector
  readonly radius: number
  readonly visible: boolean
  readonly blendMode: BlendMode
}

interface BlurEffect {
  readonly type: "LAYER_BLUR" | "BACKGROUND_BLUR"
  readonly radius: number
  readonly visible: boolean
}

type Effect = ShadowEffect | BlurEffect

type ConstraintType = "MIN" | "CENTER" | "MAX" | "STRETCH" | "SCALE"

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

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

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

interface SolidPaint {
  readonly type: "SOLID"
  readonly color: RGB

  readonly visible?: boolean
  readonly opacity?: number
  readonly blendMode?: BlendMode
}

interface GradientPaint {
  readonly type: "GRADIENT_LINEAR" | "GRADIENT_RADIAL" | "GRADIENT_ANGULAR" | "GRADIENT_DIAMOND"
  readonly gradientTransform: Transform
  readonly gradientStops: ReadonlyArray<ColorStop>

  readonly visible?: boolean
  readonly opacity?: number
  readonly blendMode?: BlendMode
}

interface ImagePaint {
  readonly type: "IMAGE"
  readonly scaleMode: "FILL" | "FIT" | "CROP" | "TILE"
  readonly imageHash: string | null
  readonly imageTransform?: Transform // setting for "CROP"
  readonly scalingFactor?: number // setting for "TILE"
  readonly filters?: ImageFilters

  readonly visible?: boolean
  readonly opacity?: number
  readonly blendMode?: BlendMode
}

type Paint = SolidPaint | GradientPaint | ImagePaint

interface Guide {
  readonly axis: "X" | "Y"
  readonly offset: number
}

interface RowsColsLayoutGrid {
  readonly pattern: "ROWS" | "COLUMNS"
  readonly alignment: "MIN" | "MAX" | "STRETCH" | "CENTER"
  readonly gutterSize: number

  readonly count: number        // Infinity when "Auto" is set in the UI
  readonly sectionSize?: number // Not set for alignment: "STRETCH"
  readonly offset?: number      // Not set for alignment: "CENTER"

  readonly visible?: boolean
  readonly color?: RGBA
}

interface GridLayoutGrid {
  readonly pattern: "GRID"
  readonly sectionSize: number

  readonly visible?: boolean
  readonly color?: RGBA
}

type LayoutGrid = RowsColsLayoutGrid | GridLayoutGrid

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

interface ExportSettingsImage {
  readonly format: "JPG" | "PNG"
  readonly contentsOnly?: boolean    // defaults to true
  readonly suffix?: string
  readonly constraint?: ExportSettingsConstraints
}

interface ExportSettingsSVG {
  readonly format: "SVG"
  readonly contentsOnly?: boolean    // defaults to true
  readonly suffix?: string
  readonly svgOutlineText?: boolean  // defaults to true
  readonly svgIdAttribute?: boolean  // defaults to false
  readonly svgSimplifyStroke?: boolean // defaults to true
}

interface ExportSettingsPDF {
  readonly format: "PDF"
  readonly contentsOnly?: boolean    // defaults to true
  readonly suffix?: string
}

type ExportSettings = ExportSettingsImage | ExportSettingsSVG | ExportSettingsPDF

type WindingRule = "NONZERO" | "EVENODD"

interface VectorVertex {
  readonly x: number
  readonly y: number
  readonly strokeCap?: StrokeCap
  readonly strokeJoin?: StrokeJoin
  readonly cornerRadius?: number
  readonly handleMirroring?: HandleMirroring
}

interface VectorSegment {
  readonly start: number
  readonly end: number
  readonly tangentStart?: Vector  // Defaults to { x: 0, y: 0 }
  readonly tangentEnd?: Vector  // Defaults to { x: 0, y: 0 }
}

interface VectorRegion {
  readonly windingRule: WindingRule
  readonly loops: ReadonlyArray<ReadonlyArray<number>>
}

interface VectorNetwork {
  readonly vertices: ReadonlyArray<VectorVertex>
  readonly segments: ReadonlyArray<VectorSegment>
  readonly regions?: ReadonlyArray<VectorRegion> // Defaults to []
}

interface VectorPath {
  readonly windingRule: WindingRule | "NONE"
  readonly data: string
}

type VectorPaths = ReadonlyArray<VectorPath>

interface LetterSpacing {
  readonly value: number
  readonly unit: "PIXELS" | "PERCENT"
}

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

type BlendMode =
  "PASS_THROUGH" |
  "NORMAL" |
  "DARKEN" |
  "MULTIPLY" |
  "LINEAR_BURN" |
  "COLOR_BURN" |
  "LIGHTEN" |
  "SCREEN" |
  "LINEAR_DODGE" |
  "COLOR_DODGE" |
  "OVERLAY" |
  "SOFT_LIGHT" |
  "HARD_LIGHT" |
  "DIFFERENCE" |
  "EXCLUSION" |
  "HUE" |
  "SATURATION" |
  "COLOR" |
  "LUMINOSITY"

interface Font {
  fontName: FontName
}

type Reaction = { action: Action, trigger: Trigger }

type Action =
  { readonly type: "BACK" | "CLOSE" } |
  { readonly type: "URL", url: string } |
  { readonly type: "NODE"
    readonly destinationId: string | null
    readonly navigation: Navigation
    readonly transition: Transition | null
    readonly preserveScrollPosition: boolean

    // Only present if navigation == "OVERLAY" and the destination uses
    // overlay position type "RELATIVE"
    readonly overlayRelativePosition?: Vector
  }

interface SimpleTransition {
  readonly type: "DISSOLVE" | "SMART_ANIMATE"
  readonly easing: Easing
  readonly duration: number
}

interface DirectionalTransition {
  readonly type: "MOVE_IN" | "MOVE_OUT" | "PUSH" | "SLIDE_IN" | "SLIDE_OUT"
  readonly direction: "LEFT" | "RIGHT" | "TOP" | "BOTTOM"
  readonly matchLayers: boolean

  readonly easing: Easing
  readonly duration: number
}

type Transition = SimpleTransition | DirectionalTransition

type Trigger =
  { readonly type: "ON_CLICK" | "ON_HOVER" | "ON_PRESS" | "ON_DRAG" } |
  { readonly type: "AFTER_TIMEOUT", readonly timeout: number } |
  { readonly type: "MOUSE_ENTER" | "MOUSE_LEAVE" | "MOUSE_UP" | "MOUSE_DOWN"
    readonly delay: number
  }

type Navigation = "NAVIGATE" | "SWAP" | "OVERLAY"

interface Easing {
  readonly type: "EASE_IN" | "EASE_OUT" | "EASE_IN_AND_OUT" | "LINEAR"
}

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

type OverlayPositionType = "CENTER" | "TOP_LEFT" | "TOP_CENTER" | "TOP_RIGHT" | "BOTTOM_LEFT" | "BOTTOM_CENTER" | "BOTTOM_RIGHT" | "MANUAL"

type OverlayBackground =
  { readonly type: "NONE" } |
  { readonly type: "SOLID_COLOR", readonly color: RGBA }

type OverlayBackgroundInteraction = "NONE" | "CLOSE_ON_CLICK_OUTSIDE"

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

interface BaseNodeMixin {
  readonly id: string
  readonly parent: (BaseNode & ChildrenMixin) | null
  name: string // Note: setting this also sets `autoRename` to false on TextNodes
  readonly removed: boolean
  toString(): string
  remove(): void

  getPluginData(key: string): string
  setPluginData(key: string, value: string): void

  // Namespace is a string that must be at least 3 alphanumeric characters, and should
  // be a name related to your plugin. Other plugins will be able to read this data.
  getSharedPluginData(namespace: string, key: string): string
  setSharedPluginData(namespace: string, key: string, value: string): void
  setRelaunchData(data: { [command: string]: /* description */ string }): void
}

interface SceneNodeMixin {
  visible: boolean
  locked: boolean
}

interface ChildrenMixin {
  readonly children: ReadonlyArray<SceneNode>

  appendChild(child: SceneNode): void
  insertChild(index: number, child: SceneNode): void

  findChildren(callback?: (node: SceneNode) => boolean): SceneNode[]
  findChild(callback: (node: SceneNode) => boolean): SceneNode | null

  /**
   * If you only need to search immediate children, it is much faster
   * to call node.children.filter(callback) or node.findChildren(callback)
   */
  findAll(callback?: (node: SceneNode) => boolean): SceneNode[]

  /**
   * If you only need to search immediate children, it is much faster
   * to call node.children.find(callback) or node.findChild(callback)
   */
  findOne(callback: (node: SceneNode) => boolean): SceneNode | null
}

interface ConstraintMixin {
  constraints: Constraints
}

interface LayoutMixin {
  readonly absoluteTransform: Transform
  relativeTransform: Transform
  x: number
  y: number
  rotation: number // In degrees

  readonly width: number
  readonly height: number
  constrainProportions: boolean

  layoutAlign: "MIN" | "CENTER" | "MAX" | "STRETCH" // applicable only inside auto-layout frames

  resize(width: number, height: number): void
  resizeWithoutConstraints(width: number, height: number): void
}

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

interface ContainerMixin {
  expanded: boolean
  backgrounds: ReadonlyArray<Paint> // DEPRECATED: use 'fills' instead
  backgroundStyleId: string // DEPRECATED: use 'fillStyleId' instead
}

type StrokeCap = "NONE" | "ROUND" | "SQUARE" | "ARROW_LINES" | "ARROW_EQUILATERAL"
type StrokeJoin = "MITER" | "BEVEL" | "ROUND"
type HandleMirroring = "NONE" | "ANGLE" | "ANGLE_AND_LENGTH"

interface GeometryMixin {
  fills: ReadonlyArray<Paint> | PluginAPI['mixed']
  strokes: ReadonlyArray<Paint>
  strokeWeight: number
  strokeMiterLimit: number
  strokeAlign: "CENTER" | "INSIDE" | "OUTSIDE"
  strokeCap: StrokeCap | PluginAPI['mixed']
  strokeJoin: StrokeJoin | PluginAPI['mixed']
  dashPattern: ReadonlyArray<number>
  fillStyleId: string | PluginAPI['mixed']
  strokeStyleId: string
  outlineStroke(): VectorNode | null
}

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

interface RectangleCornerMixin {
  topLeftRadius: number
  topRightRadius: number
  bottomLeftRadius: number
  bottomRightRadius: number
}

interface ExportMixin {
  exportSettings: ReadonlyArray<ExportSettings>
  exportAsync(settings?: ExportSettings): Promise<Uint8Array> // Defaults to PNG format
}

interface ReactionMixin {
  readonly reactions: ReadonlyArray<Reaction>
}

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

interface DefaultFrameMixin extends
  BaseNodeMixin, SceneNodeMixin, ReactionMixin,
  ChildrenMixin, ContainerMixin,
  GeometryMixin, CornerMixin, RectangleCornerMixin,
  BlendMixin, ConstraintMixin, LayoutMixin,
  ExportMixin {

  layoutMode: "NONE" | "HORIZONTAL" | "VERTICAL"
  counterAxisSizingMode: "FIXED" | "AUTO" // applicable only if layoutMode != "NONE"
  horizontalPadding: number // applicable only if layoutMode != "NONE"
  verticalPadding: number // applicable only if layoutMode != "NONE"
  itemSpacing: number // applicable only if layoutMode != "NONE"

  layoutGrids: ReadonlyArray<LayoutGrid>
  gridStyleId: string
  clipsContent: boolean
  guides: ReadonlyArray<Guide>

  overflowDirection: OverflowDirection
  numberOfFixedChildren: number

  readonly overlayPositionType: OverlayPositionType
  readonly overlayBackground: OverlayBackground
  readonly overlayBackgroundInteraction: OverlayBackgroundInteraction
}

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

interface DocumentNode extends BaseNodeMixin {
  readonly type: "DOCUMENT"

  readonly children: ReadonlyArray<PageNode>

  appendChild(child: PageNode): void
  insertChild(index: number, child: PageNode): void
  findChildren(callback?: (node: PageNode) => boolean): Array<PageNode>
  findChild(callback: (node: PageNode) => boolean): PageNode | null

  /**
   * If you only need to search immediate children, it is much faster
   * to call node.children.filter(callback) or node.findChildren(callback)
   */
  findAll(callback?: (node: PageNode | SceneNode) => boolean): Array<PageNode | SceneNode>

  /**
   * If you only need to search immediate children, it is much faster
   * to call node.children.find(callback) or node.findChild(callback)
   */
  findOne(callback: (node: PageNode | SceneNode) => boolean): PageNode | SceneNode | null
}

interface PageNode extends BaseNodeMixin, ChildrenMixin, ExportMixin {

  readonly type: "PAGE"
  clone(): PageNode

  guides: ReadonlyArray<Guide>
  selection: ReadonlyArray<SceneNode>
  selectedTextRange: { node: TextNode, start: number, end: number } | null

  backgrounds: ReadonlyArray<Paint>

  readonly prototypeStartNode: FrameNode | GroupNode | ComponentNode | InstanceNode | null
}

interface FrameNode extends DefaultFrameMixin {
  readonly type: "FRAME"
  clone(): FrameNode
}

interface GroupNode extends
  BaseNodeMixin, SceneNodeMixin, ReactionMixin,
  ChildrenMixin, ContainerMixin, BlendMixin,
  LayoutMixin, ExportMixin {

  readonly type: "GROUP"
  clone(): GroupNode
}

interface SliceNode extends
  BaseNodeMixin, SceneNodeMixin, LayoutMixin,
  ExportMixin {

  readonly type: "SLICE"
  clone(): SliceNode
}

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

interface LineNode extends DefaultShapeMixin, ConstraintMixin {
  readonly type: "LINE"
  clone(): LineNode
}

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

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

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

interface VectorNode extends DefaultShapeMixin, ConstraintMixin, CornerMixin {
  readonly type: "VECTOR"
  clone(): VectorNode
  vectorNetwork: VectorNetwork
  vectorPaths: VectorPaths
  handleMirroring: HandleMirroring | PluginAPI['mixed']
}

interface TextNode extends DefaultShapeMixin, ConstraintMixin {
  readonly type: "TEXT"
  clone(): TextNode
  readonly hasMissingFont: boolean
  textAlignHorizontal: "LEFT" | "CENTER" | "RIGHT" | "JUSTIFIED"
  textAlignVertical: "TOP" | "CENTER" | "BOTTOM"
  textAutoResize: "NONE" | "WIDTH_AND_HEIGHT" | "HEIGHT"
  paragraphIndent: number
  paragraphSpacing: number
  autoRename: boolean

  textStyleId: string | PluginAPI['mixed']
  fontSize: number | PluginAPI['mixed']
  fontName: FontName | PluginAPI['mixed']
  textCase: TextCase | PluginAPI['mixed']
  textDecoration: TextDecoration | PluginAPI['mixed']
  letterSpacing: LetterSpacing | PluginAPI['mixed']
  lineHeight: LineHeight | PluginAPI['mixed']

  characters: string
  insertCharacters(start: number, characters: string, useStyle?: "BEFORE" | "AFTER"): void
  deleteCharacters(start: number, end: number): void

  getRangeFontSize(start: number, end: number): number | PluginAPI['mixed']
  setRangeFontSize(start: number, end: number, value: number): void
  getRangeFontName(start: number, end: number): FontName | PluginAPI['mixed']
  setRangeFontName(start: number, end: number, value: FontName): void
  getRangeTextCase(start: number, end: number): TextCase | PluginAPI['mixed']
  setRangeTextCase(start: number, end: number, value: TextCase): void
  getRangeTextDecoration(start: number, end: number): TextDecoration | PluginAPI['mixed']
  setRangeTextDecoration(start: number, end: number, value: TextDecoration): void
  getRangeLetterSpacing(start: number, end: number): LetterSpacing | PluginAPI['mixed']
  setRangeLetterSpacing(start: number, end: number, value: LetterSpacing): void
  getRangeLineHeight(start: number, end: number): LineHeight | PluginAPI['mixed']
  setRangeLineHeight(start: number, end: number, value: LineHeight): void
  getRangeFills(start: number, end: number): Paint[] | PluginAPI['mixed']
  setRangeFills(start: number, end: number, value: Paint[]): void
  getRangeTextStyleId(start: number, end: number): string | PluginAPI['mixed']
  setRangeTextStyleId(start: number, end: number, value: string): void
  getRangeFillStyleId(start: number, end: number): string | PluginAPI['mixed']
  setRangeFillStyleId(start: number, end: number, value: string): void
}

interface ComponentNode extends DefaultFrameMixin {
  readonly type: "COMPONENT"
  clone(): ComponentNode

  createInstance(): InstanceNode
  description: string
  readonly remote: boolean
  readonly key: string // The key to use with "importComponentByKeyAsync"
}

interface InstanceNode extends DefaultFrameMixin  {
  readonly type: "INSTANCE"
  clone(): InstanceNode
  masterComponent: ComponentNode
  scaleFactor: number
}

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

  expanded: boolean
}

type BaseNode =
  DocumentNode |
  PageNode |
  SceneNode

type SceneNode =
  SliceNode |
  FrameNode |
  GroupNode |
  ComponentNode |
  InstanceNode |
  BooleanOperationNode |
  VectorNode |
  StarNode |
  LineNode |
  EllipseNode |
  PolygonNode |
  RectangleNode |
  TextNode

type NodeType =
  "DOCUMENT" |
  "PAGE" |
  "SLICE" |
  "FRAME" |
  "GROUP" |
  "COMPONENT" |
  "INSTANCE" |
  "BOOLEAN_OPERATION" |
  "VECTOR" |
  "STAR" |
  "LINE" |
  "ELLIPSE" |
  "POLYGON" |
  "RECTANGLE" |
  "TEXT"

////////////////////////////////////////////////////////////////////////////////
// Styles
type StyleType = "PAINT" | "TEXT" | "EFFECT" | "GRID"

interface BaseStyle {
  readonly id: string
  readonly type: StyleType
  name: string
  description: string
  remote: boolean
  readonly key: string // The key to use with "importStyleByKeyAsync"
  remove(): void
}

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

interface TextStyle extends BaseStyle {
  type: "TEXT"
  fontSize: number
  textDecoration: TextDecoration
  fontName: FontName
  letterSpacing: LetterSpacing
  lineHeight: LineHeight
  paragraphIndent: number
  paragraphSpacing: number
  textCase: TextCase
}

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

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

////////////////////////////////////////////////////////////////////////////////
// Other

interface Image {
  readonly hash: string
  getBytesAsync(): Promise<Uint8Array>
}
} // declare global

export {}