type ArgFreeEventType = 'selectionchange' | 'currentpagechange' | 'close' | 'timerstart' | 'timerstop' | 'timerpause' | 'timerresume' | 'timeradjust' | 'timerdone';
export interface PluginAPI {
    readonly apiVersion: '1.0.0';
    readonly command: string;
    readonly editorType: 'figma' | 'figjam';
    readonly pluginId?: string;
    readonly widgetId?: string;
    readonly fileKey: string | undefined;
    skipInvisibleInstanceChildren: boolean;
    readonly timer?: TimerAPI;
    readonly viewport: ViewportAPI;
    readonly currentUser: User | null;
    readonly activeUsers: ActiveUser[];
    closePlugin(message?: string): void;
    notify(message: string, options?: NotificationOptions): NotificationHandler;
    commitUndo(): void;
    triggerUndo(): void;
    saveVersionHistoryAsync(title: string, description?: string): Promise<VersionHistoryResult>;
    showUI(html: string, options?: ShowUIOptions): void;
    readonly ui: UIAPI;
    readonly clientStorage: ClientStorageAPI;
    readonly parameters: ParametersAPI;
    getNodeById(id: string): BaseNode | null;
    getStyleById(id: string): BaseStyle | null;
    readonly root: DocumentNode;
    currentPage: PageNode;
    on(type: ArgFreeEventType, callback: () => void): void;
    on(type: 'run', callback: (event: RunEvent) => void): void;
    on(type: 'drop', callback: (event: DropEvent) => boolean): void;
    once(type: ArgFreeEventType, callback: () => void): void;
    once(type: 'run', callback: (event: RunEvent) => void): void;
    once(type: 'drop', callback: (event: DropEvent) => boolean): void;
    off(type: ArgFreeEventType, callback: () => void): void;
    off(type: 'run', callback: (event: RunEvent) => void): void;
    off(type: 'drop', callback: (event: DropEvent) => boolean): 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;
    createSticky(): StickyNode;
    createConnector(): ConnectorNode;
    createShapeWithText(): ShapeWithTextNode;
    createCodeBlock(): CodeBlockNode;
    createSection(): SectionNode;
    /**
     * [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;
    getLocalPaintStyles(): PaintStyle[];
    getLocalTextStyles(): TextStyle[];
    getLocalEffectStyles(): EffectStyle[];
    getLocalGridStyles(): GridStyle[];
    moveLocalPaintStyleAfter(targetNode: PaintStyle, reference: PaintStyle | null): void;
    moveLocalTextStyleAfter(targetNode: TextStyle, reference: TextStyle | null): void;
    moveLocalEffectStyleAfter(targetNode: EffectStyle, reference: EffectStyle | null): void;
    moveLocalGridStyleAfter(targetNode: GridStyle, reference: GridStyle | null): void;
    moveLocalPaintFolderAfter(targetFolder: string, reference: string | null): void;
    moveLocalTextFolderAfter(targetFolder: string, reference: string | null): void;
    moveLocalEffectFolderAfter(targetFolder: string, reference: string | null): void;
    moveLocalGridFolderAfter(targetFolder: string, reference: string | null): void;
    importComponentByKeyAsync(key: string): Promise<ComponentNode>;
    importComponentSetByKeyAsync(key: string): Promise<ComponentSetNode>;
    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 | null;
    createLinkPreviewAsync(url: string): Promise<EmbedNode | LinkUnfurlNode>;
    createGif(hash: string): MediaNode;
    combineAsVariants(nodes: ReadonlyArray<ComponentNode>, parent: BaseNode & ChildrenMixin, index?: number): ComponentSetNode;
    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;
    base64Encode(data: Uint8Array): string;
    base64Decode(data: string): Uint8Array;
    getFileThumbnailNode(): FrameNode | ComponentNode | ComponentSetNode | null;
    setFileThumbnailNodeAsync(node: FrameNode | ComponentNode | ComponentSetNode | null): Promise<void>;
}
interface VersionHistoryResult {
    id: string;
}
interface ClientStorageAPI {
    getAsync(key: string): Promise<any | undefined>;
    setAsync(key: string, value: any): Promise<void>;
    deleteAsync(key: string): Promise<void>;
    keysAsync(): Promise<string[]>;
}
interface NotificationOptions {
    timeout?: number;
    error?: boolean;
}
interface NotificationHandler {
    cancel: () => void;
}
interface ShowUIOptions {
    visible?: boolean;
    title?: string;
    width?: number;
    height?: number;
    position?: {
        x: number;
        y: 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 TimerAPI {
    readonly remaining: number;
    readonly total: number;
    readonly state: 'STOPPED' | 'PAUSED' | 'RUNNING';
    pause: () => void;
    resume: () => void;
    start: (seconds: number) => void;
    stop: () => void;
}
interface ViewportAPI {
    center: Vector;
    zoom: number;
    scrollAndZoomIntoView(nodes: ReadonlyArray<BaseNode>): void;
    readonly bounds: Rect;
}
interface ParameterValues {
    [key: string]: any;
}
interface SuggestionResults {
    setSuggestions(suggestions: Array<string | {
        name: string;
        data?: any;
        icon?: string | Uint8Array;
        iconUrl?: string;
    }>): void;
    setError(message: string): void;
    setLoadingMessage(message: string): void;
}
type ParameterInputEvent<ParametersType = ParameterValues> = {
    query: string;
    key: string;
    parameters: Partial<ParametersType>;
    result: SuggestionResults;
};
interface ParametersAPI {
    on(type: 'input', callback: (event: ParameterInputEvent) => void): void;
    once(type: 'input', callback: (event: ParameterInputEvent) => void): void;
    off(type: 'input', callback: (event: ParameterInputEvent) => void): void;
}
interface RunEvent<ParametersType = ParameterValues | undefined> {
    command: string;
    parameters: ParametersType;
}
interface DropEvent {
    node: BaseNode | SceneNode;
    x: number;
    y: number;
    absoluteX: number;
    absoluteY: number;
    items: DropItem[];
    files: DropFile[];
    dropMetadata?: any;
}
interface DropItem {
    type: string;
    data: string;
}
interface DropFile {
    name: string;
    type: string;
    getBytesAsync(): Promise<Uint8Array>;
    getTextAsync(): Promise<string>;
}
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 DropShadowEffect {
    readonly type: 'DROP_SHADOW';
    readonly color: RGBA;
    readonly offset: Vector;
    readonly radius: number;
    readonly spread?: number;
    readonly visible: boolean;
    readonly blendMode: BlendMode;
    readonly showShadowBehindNode?: boolean;
}
interface InnerShadowEffect {
    readonly type: 'INNER_SHADOW';
    readonly color: RGBA;
    readonly offset: Vector;
    readonly radius: number;
    readonly spread?: number;
    readonly visible: boolean;
    readonly blendMode: BlendMode;
}
interface BlurEffect {
    readonly type: 'LAYER_BLUR' | 'BACKGROUND_BLUR';
    readonly radius: number;
    readonly visible: boolean;
}
type Effect = DropShadowEffect | InnerShadowEffect | 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;
    readonly scalingFactor?: number;
    readonly rotation?: number;
    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;
    readonly sectionSize?: number;
    readonly offset?: number;
    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;
    readonly useAbsoluteBounds?: boolean;
    readonly suffix?: string;
    readonly constraint?: ExportSettingsConstraints;
}
interface ExportSettingsSVG {
    readonly format: 'SVG';
    readonly contentsOnly?: boolean;
    readonly useAbsoluteBounds?: boolean;
    readonly suffix?: string;
    readonly svgOutlineText?: boolean;
    readonly svgIdAttribute?: boolean;
    readonly svgSimplifyStroke?: boolean;
}
interface ExportSettingsPDF {
    readonly format: 'PDF';
    readonly contentsOnly?: boolean;
    readonly useAbsoluteBounds?: boolean;
    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;
    readonly tangentEnd?: Vector;
}
interface VectorRegion {
    readonly windingRule: WindingRule;
    readonly loops: ReadonlyArray<ReadonlyArray<number>>;
    readonly fills?: ReadonlyArray<Paint>;
    readonly fillStyleId?: string;
}
interface VectorNetwork {
    readonly vertices: ReadonlyArray<VectorVertex>;
    readonly segments: ReadonlyArray<VectorSegment>;
    readonly regions?: ReadonlyArray<VectorRegion>;
}
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 HyperlinkTarget = {
    type: 'URL' | 'NODE';
    value: string;
};
type TextListOptions = {
    type: 'ORDERED' | 'UNORDERED' | 'NONE';
};
type BlendMode = '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;
}
interface StyledTextSegment {
    characters: string;
    start: number;
    end: number;
    fontSize: number;
    fontName: FontName;
    textDecoration: TextDecoration;
    textCase: TextCase;
    lineHeight: LineHeight;
    letterSpacing: LetterSpacing;
    fills: Paint[];
    textStyleId: string;
    fillStyleId: string;
    listOptions: TextListOptions;
    indentation: number;
    hyperlink: HyperlinkTarget | null;
}
type Reaction = {
    action: Action | null;
    trigger: Trigger | null;
};
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;
    readonly overlayRelativePosition?: Vector;
};
interface SimpleTransition {
    readonly type: 'DISSOLVE' | 'SMART_ANIMATE' | 'SCROLL_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;
} | {
    readonly type: 'ON_KEY_DOWN';
    readonly device: 'KEYBOARD' | 'XBOX_ONE' | 'PS4' | 'SWITCH_PRO' | 'UNKNOWN_CONTROLLER';
    readonly keyCodes: ReadonlyArray<number>;
};
type Navigation = 'NAVIGATE' | 'SWAP' | 'OVERLAY' | 'SCROLL_TO' | 'CHANGE_TO';
interface Easing {
    readonly type: 'EASE_IN' | 'EASE_OUT' | 'EASE_IN_AND_OUT' | 'LINEAR' | 'EASE_IN_BACK' | 'EASE_OUT_BACK' | 'EASE_IN_AND_OUT_BACK' | 'CUSTOM_CUBIC_BEZIER';
    readonly easingFunctionCubicBezier?: EasingFunctionBezier;
}
interface EasingFunctionBezier {
    x1: number;
    y1: number;
    x2: number;
    y2: number;
}
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';
type PublishStatus = 'UNPUBLISHED' | 'CURRENT' | 'CHANGED';
interface ConnectorEndpointPosition {
    position: {
        x: number;
        y: number;
    };
}
interface ConnectorEndpointPositionAndEndpointNodeId {
    position: {
        x: number;
        y: number;
    };
    endpointNodeId: string;
}
interface ConnectorEndpointEndpointNodeIdAndMagnet {
    endpointNodeId: string;
    magnet: 'NONE' | 'AUTO' | 'TOP' | 'LEFT' | 'BOTTOM' | 'RIGHT';
}
type ConnectorEndpoint = ConnectorEndpointPosition | ConnectorEndpointEndpointNodeIdAndMagnet | ConnectorEndpointPositionAndEndpointNodeId;
type ConnectorStrokeCap = 'NONE' | 'ARROW_EQUILATERAL' | 'ARROW_LINES' | 'TRIANGLE_FILLED' | 'DIAMOND_FILLED' | 'CIRCLE_FILLED';
interface BaseNodeMixin extends PluginDataMixin {
    readonly id: string;
    readonly parent: (BaseNode & ChildrenMixin) | null;
    name: string;
    readonly removed: boolean;
    toString(): string;
    remove(): void;
    setRelaunchData(data: {
        [command: string]: string;
    }): void;
    getRelaunchData(): {
        [command: string]: string;
    };
}
interface PluginDataMixin {
    getPluginData(key: string): string;
    setPluginData(key: string, value: string): void;
    getPluginDataKeys(): string[];
    getSharedPluginData(namespace: string, key: string): string;
    setSharedPluginData(namespace: string, key: string, value: string): void;
    getSharedPluginDataKeys(namespace: string): string[];
}
interface SceneNodeMixin {
    visible: boolean;
    locked: boolean;
    stuckNodes: SceneNode[];
}
interface StickableMixin {
    stuckTo: SceneNode | null;
}
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;
    findAllWithCriteria<T extends NodeType[]>(criteria: {
        types: T;
    }): Array<{
        type: T[number];
    } & SceneNode>;
}
interface ConstraintMixin {
    constraints: Constraints;
}
interface LayoutMixin {
    readonly absoluteTransform: Transform;
    relativeTransform: Transform;
    x: number;
    y: number;
    rotation: number;
    readonly width: number;
    readonly height: number;
    readonly absoluteRenderBounds: Rect | null;
    constrainProportions: boolean;
    layoutAlign: 'MIN' | 'CENTER' | 'MAX' | 'STRETCH' | 'INHERIT';
    layoutGrow: number;
    resize(width: number, height: number): void;
    resizeWithoutConstraints(width: number, height: number): void;
    rescale(scale: number): void;
}
interface BlendMixin {
    opacity: number;
    blendMode: 'PASS_THROUGH' | BlendMode;
    isMask: boolean;
    effects: ReadonlyArray<Effect>;
    effectStyleId: string;
}
interface ContainerMixin {
    expanded: boolean;
    backgrounds: ReadonlyArray<Paint>;
    backgroundStyleId: string;
}
type StrokeCap = 'NONE' | 'ROUND' | 'SQUARE' | 'ARROW_LINES' | 'ARROW_EQUILATERAL';
type StrokeJoin = 'MITER' | 'BEVEL' | 'ROUND';
type HandleMirroring = 'NONE' | 'ANGLE' | 'ANGLE_AND_LENGTH';
interface MinimalStrokesMixin {
    strokes: ReadonlyArray<Paint>;
    strokeStyleId: string;
    strokeWeight: number;
    strokeJoin: StrokeJoin | PluginAPI['mixed'];
    strokeAlign: 'CENTER' | 'INSIDE' | 'OUTSIDE';
    dashPattern: ReadonlyArray<number>;
    strokeGeometry: VectorPaths;
}
interface MinimalFillsMixin {
    fills: ReadonlyArray<Paint> | PluginAPI['mixed'];
    fillStyleId: string | PluginAPI['mixed'];
    fillGeometry: VectorPaths;
}
interface GeometryMixin extends MinimalStrokesMixin, MinimalFillsMixin {
    strokeCap: StrokeCap | PluginAPI['mixed'];
    strokeMiterLimit: number;
    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>;
}
interface FramePrototypingMixin {
    overflowDirection: OverflowDirection;
    numberOfFixedChildren: number;
    readonly overlayPositionType: OverlayPositionType;
    readonly overlayBackground: OverlayBackground;
    readonly overlayBackgroundInteraction: OverlayBackgroundInteraction;
}
interface VectorLikeMixin {
    vectorNetwork: VectorNetwork;
    vectorPaths: VectorPaths;
    handleMirroring: HandleMirroring | PluginAPI['mixed'];
}
interface ReactionMixin {
    reactions: ReadonlyArray<Reaction>;
}
interface DocumentationLink {
    readonly uri: string;
}
interface PublishableMixin {
    description: string;
    documentationLinks: ReadonlyArray<DocumentationLink>;
    readonly remote: boolean;
    readonly key: string;
    getPublishStatusAsync(): Promise<PublishStatus>;
}
interface DefaultShapeMixin extends BaseNodeMixin, SceneNodeMixin, ReactionMixin, BlendMixin, GeometryMixin, LayoutMixin, ExportMixin {
}
interface BaseFrameMixin extends BaseNodeMixin, SceneNodeMixin, ChildrenMixin, ContainerMixin, GeometryMixin, CornerMixin, RectangleCornerMixin, BlendMixin, ConstraintMixin, LayoutMixin, ExportMixin {
    layoutMode: 'NONE' | 'HORIZONTAL' | 'VERTICAL';
    primaryAxisSizingMode: 'FIXED' | 'AUTO';
    counterAxisSizingMode: 'FIXED' | 'AUTO';
    primaryAxisAlignItems: 'MIN' | 'MAX' | 'CENTER' | 'SPACE_BETWEEN';
    counterAxisAlignItems: 'MIN' | 'MAX' | 'CENTER';
    paddingLeft: number;
    paddingRight: number;
    paddingTop: number;
    paddingBottom: number;
    itemSpacing: number;
    horizontalPadding: number;
    verticalPadding: number;
    layoutGrids: ReadonlyArray<LayoutGrid>;
    gridStyleId: string;
    clipsContent: boolean;
    guides: ReadonlyArray<Guide>;
}
interface DefaultFrameMixin extends BaseFrameMixin, FramePrototypingMixin, ReactionMixin {
}
interface OpaqueNodeMixin extends BaseNodeMixin, SceneNodeMixin, ExportMixin {
    readonly absoluteTransform: Transform;
    relativeTransform: Transform;
    x: number;
    y: number;
    readonly width: number;
    readonly height: number;
}
interface MinimalBlendMixin {
    readonly opacity?: number;
    readonly blendMode?: BlendMode;
}
interface VariantMixin {
    readonly variantProperties: {
        [property: string]: string;
    } | null;
}
interface TextSublayerNode {
    readonly hasMissingFont: boolean;
    paragraphIndent: number;
    paragraphSpacing: number;
    fontSize: number | PluginAPI['mixed'];
    fontName: FontName | PluginAPI['mixed'];
    textCase: TextCase | PluginAPI['mixed'];
    textDecoration: TextDecoration | PluginAPI['mixed'];
    letterSpacing: LetterSpacing | PluginAPI['mixed'];
    lineHeight: LineHeight | PluginAPI['mixed'];
    hyperlink: HyperlinkTarget | null | 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;
    getRangeAllFontNames(start: number, end: number): FontName[];
    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;
    getRangeHyperlink(start: number, end: number): HyperlinkTarget | null | PluginAPI['mixed'];
    setRangeHyperlink(start: number, end: number, value: HyperlinkTarget | null): 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;
    getRangeListOptions(start: number, end: number): TextListOptions | PluginAPI['mixed'];
    setRangeListOptions(start: number, end: number, value: TextListOptions): void;
    getRangeIndentation(start: number, end: number): number | PluginAPI['mixed'];
    setRangeIndentation(start: number, end: number, value: number): void;
    getStyledTextSegments<StyledTextSegmentFields extends (keyof Omit<StyledTextSegment, 'characters' | 'start' | 'end'>)[]>(fields: StyledTextSegmentFields, start?: number, end?: number): Array<Pick<StyledTextSegment, StyledTextSegmentFields[number] | 'characters' | 'start' | 'end'>>;
}
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;
    findAllWithCriteria<T extends NodeType[]>(criteria: {
        types: T;
    }): Array<{
        type: T[number];
    } & (PageNode | SceneNode)>;
}
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;
    flowStartingPoints: ReadonlyArray<{
        nodeId: string;
        name: string;
    }>;
    backgrounds: ReadonlyArray<Paint>;
    prototypeBackgrounds: 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, VectorLikeMixin {
    readonly type: 'VECTOR';
    clone(): VectorNode;
}
interface TextNode extends DefaultShapeMixin, ConstraintMixin, TextSublayerNode {
    readonly type: 'TEXT';
    clone(): TextNode;
    textAlignHorizontal: 'LEFT' | 'CENTER' | 'RIGHT' | 'JUSTIFIED';
    textAlignVertical: 'TOP' | 'CENTER' | 'BOTTOM';
    textAutoResize: 'NONE' | 'WIDTH_AND_HEIGHT' | 'HEIGHT';
    autoRename: boolean;
    textStyleId: string | PluginAPI['mixed'];
}
interface ComponentSetNode extends BaseFrameMixin, PublishableMixin {
    readonly type: 'COMPONENT_SET';
    clone(): ComponentSetNode;
    readonly defaultVariant: ComponentNode;
    readonly variantGroupProperties: {
        [property: string]: {
            values: string[];
        };
    };
}
interface ComponentNode extends DefaultFrameMixin, PublishableMixin, VariantMixin {
    readonly type: 'COMPONENT';
    clone(): ComponentNode;
    createInstance(): InstanceNode;
}
interface InstanceNode extends DefaultFrameMixin, VariantMixin {
    readonly type: 'INSTANCE';
    clone(): InstanceNode;
    mainComponent: ComponentNode | null;
    swapComponent(componentNode: ComponentNode): void;
    setProperties(properties: {
        [property: string]: string;
    }): void;
    detachInstance(): FrameNode;
    scaleFactor: number;
}
interface BooleanOperationNode extends DefaultShapeMixin, ChildrenMixin, CornerMixin {
    readonly type: 'BOOLEAN_OPERATION';
    clone(): BooleanOperationNode;
    booleanOperation: 'UNION' | 'INTERSECT' | 'SUBTRACT' | 'EXCLUDE';
    expanded: boolean;
}
interface StickyNode extends OpaqueNodeMixin, MinimalFillsMixin, MinimalBlendMixin {
    readonly type: 'STICKY';
    readonly text: TextSublayerNode;
    authorVisible: boolean;
    authorName: string;
    resize(width: number, height: number): void;
    rescale(scale: number): void;
    clone(): StickyNode;
}
interface StampNode extends DefaultShapeMixin, ConstraintMixin, StickableMixin {
    readonly type: 'STAMP';
    clone(): StampNode;
}
interface HighlightNode extends DefaultShapeMixin, ConstraintMixin, CornerMixin, ReactionMixin, VectorLikeMixin, StickableMixin {
    readonly type: 'HIGHLIGHT';
    clone(): HighlightNode;
}
interface WashiTapeNode extends DefaultShapeMixin, StickableMixin {
    readonly type: 'WASHI_TAPE';
    clone(): WashiTapeNode;
}
interface ShapeWithTextNode extends OpaqueNodeMixin, MinimalFillsMixin, MinimalBlendMixin, MinimalStrokesMixin {
    readonly type: 'SHAPE_WITH_TEXT';
    shapeType: 'SQUARE' | 'ELLIPSE' | 'ROUNDED_RECTANGLE' | 'DIAMOND' | 'TRIANGLE_UP' | 'TRIANGLE_DOWN' | 'PARALLELOGRAM_RIGHT' | 'PARALLELOGRAM_LEFT' | 'ENG_DATABASE' | 'ENG_QUEUE' | 'ENG_FILE' | 'ENG_FOLDER';
    readonly text: TextSublayerNode;
    readonly cornerRadius?: number;
    resize(width: number, height: number): void;
    rescale(scale: number): void;
    clone(): ShapeWithTextNode;
}
interface CodeBlockNode extends OpaqueNodeMixin, MinimalBlendMixin {
    readonly type: 'CODE_BLOCK';
    code: string;
    codeLanguage: 'TYPESCRIPT' | 'CPP' | 'RUBY' | 'CSS' | 'JAVASCRIPT' | 'HTML' | 'JSON' | 'GRAPHQL' | 'PYTHON' | 'GO' | 'SQL' | 'SWIFT' | 'KOTLIN' | 'RUST';
    clone(): CodeBlockNode;
}
interface LayerSublayerNode {
    fills: Paint[] | PluginAPI['mixed'];
}
interface ConnectorNode extends OpaqueNodeMixin, MinimalBlendMixin, MinimalStrokesMixin {
    readonly type: 'CONNECTOR';
    readonly text: TextSublayerNode;
    readonly textBackground: LayerSublayerNode;
    readonly cornerRadius?: number;
    connectorLineType: 'ELBOWED' | 'STRAIGHT';
    connectorStart: ConnectorEndpoint;
    connectorEnd: ConnectorEndpoint;
    connectorStartStrokeCap: ConnectorStrokeCap;
    connectorEndStrokeCap: ConnectorStrokeCap;
    clone(): ConnectorNode;
}
interface WidgetNode extends OpaqueNodeMixin, StickableMixin {
    readonly type: 'WIDGET';
    readonly widgetId: string;
    readonly widgetSyncedState: {
        [key: string]: any;
    };
    clone(): WidgetNode;
    cloneWidget(syncedStateOverrides: {
        [name: string]: any;
    }, syncedMapOverrides?: {
        [mapName: string]: {
            [key: string]: any;
        };
    }): WidgetNode;
}
interface EmbedData {
    srcUrl: string;
    canonicalUrl: string | null;
    title: string | null;
    description: string | null;
    provider: string | null;
}
interface EmbedNode extends OpaqueNodeMixin, SceneNodeMixin {
    readonly type: 'EMBED';
    readonly embedData: EmbedData;
    clone(): EmbedNode;
}
interface LinkUnfurlData {
    url: string;
    title: string | null;
    description: string | null;
    provider: string | null;
}
interface LinkUnfurlNode extends OpaqueNodeMixin, SceneNodeMixin {
    readonly type: 'LINK_UNFURL';
    readonly linkUnfurlData: LinkUnfurlData;
    clone(): LinkUnfurlNode;
}
interface MediaData {
    hash: string;
}
interface MediaNode extends OpaqueNodeMixin {
    readonly type: 'MEDIA';
    readonly mediaData: MediaData;
    resize(width: number, height: number): void;
    resizeWithoutConstraints(width: number, height: number): void;
    clone(): MediaNode;
}
interface SectionNode extends ChildrenMixin, MinimalFillsMixin, OpaqueNodeMixin {
    readonly type: 'SECTION';
    clone(): SectionNode;
    resizeWithoutConstraints(width: number, height: number): void;
}
type BaseNode = DocumentNode | PageNode | SceneNode;
type SceneNode = SliceNode | FrameNode | GroupNode | ComponentSetNode | ComponentNode | InstanceNode | BooleanOperationNode | VectorNode | StarNode | LineNode | EllipseNode | PolygonNode | RectangleNode | TextNode | StickyNode | ConnectorNode | ShapeWithTextNode | CodeBlockNode | StampNode | WidgetNode | EmbedNode | LinkUnfurlNode | MediaNode | SectionNode | HighlightNode | WashiTapeNode;
type NodeType = BaseNode['type'];
type StyleType = 'PAINT' | 'TEXT' | 'EFFECT' | 'GRID';
interface BaseStyle extends PublishableMixin, PluginDataMixin {
    readonly id: string;
    readonly type: StyleType;
    name: string;
    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>;
}
interface Image {
    readonly hash: string;
    getBytesAsync(): Promise<Uint8Array>;
}
interface User {
    readonly id: string | null;
    readonly name: string;
    readonly photoUrl: string | null;
    readonly color: string;
    readonly sessionId: number;
}
interface ActiveUser extends User {
    readonly position: Vector | null;
    readonly viewport: Rect;
    readonly selection: string[];
}
export declare const figma: PluginAPI;
export declare const getCodeString: (func: any) => any;
export declare const postFigmaMessage: (func: any) => Promise<void>;
export declare const postFigmaMessageForExport: (option: any, callback: any, controller: any) => Promise<void>;
export declare const postFigmaMessageForSnapShot: (func: any) => Promise<void>;
export {};
//# sourceMappingURL=FigmaApi.d.ts.map