@supernova-studio/supernova-sdk-beta 0.7.17

package/build/sdk-typescript/src/tools/design-tokens/utilities/SDKDTMapLoader.d.ts

@@ -0,0 +1,39 @@
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
+import { DTParsedNode } from "./SDKDTJSONLoader";
+export type DTPluginToSupernovaMapPack = Array<DTPluginToSupernovaMap>;
+export declare enum DTPluginToSupernovaMapType {
+    theme = "theme",
+    set = "set"
+}
+export type DTPluginToSupernovaMap = {
+    type: DTPluginToSupernovaMapType;
+    pluginSets: Array<string> | null;
+    pluginTheme: string | Array<string> | null;
+    bindToBrand: string;
+    bindToTheme: string | null;
+    nodes: Array<DTParsedNode> | null;
+    processedNodes: Array<DTProcessedTokenNode> | null;
+    processedGroups: Array<TokenGroup> | null;
+};
+export type DTPluginToSupernovaMappingFile = {
+    mode: "single-file" | "multi-file";
+    mapping: [
+        {
+            tokensTheme?: string | Array<string>;
+            tokenSets?: Array<string>;
+            supernovaBrand: string;
+            supernovaTheme?: string;
+        }
+    ];
+    settings?: {
+        verbose?: boolean;
+        dryRun?: boolean;
+        preciseCopy?: boolean;
+    };
+};
+export type DTPluginToSupernovaSettings = {
+    verbose: boolean;
+    dryRun: boolean;
+    preciseCopy: boolean;
+};

package/build/sdk-typescript/src/tools/design-tokens/utilities/SDKDTMapResolver.d.ts

@@ -0,0 +1,7 @@
+import { DTParsedTheme, DTParsedTokenSet } from "./SDKDTJSONLoader";
+import { DTPluginToSupernovaMap } from "./SDKDTMapLoader";
+/** Utility to resolve token maps */
+export declare class DTMapResolver {
+    mappedNodePools(map: DTPluginToSupernovaMap, themes: Array<DTParsedTheme>, sets: Array<DTParsedTokenSet>): DTPluginToSupernovaMap;
+    private computeUniqueNodesFromSets;
+}

package/build/sdk-typescript/src/tools/design-tokens/utilities/SDKDTThemeMerger.d.ts

@@ -0,0 +1,15 @@
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { TokenTheme } from "../../../model/themes/SDKTokenTheme";
+import { Token } from "../../../model/tokens/SDKToken";
+import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
+export type DTThemeMergeDiff = {
+    toUpdate: Array<DTProcessedTokenNode>;
+    toCreate: Array<DTProcessedTokenNode>;
+};
+/** Utility allowing merging of two pools of tokens */
+export declare class DTThemeMerger {
+    private versionId;
+    constructor(versionId: string);
+    makeTheme(upstreamTokens: Array<Token>, upstreamGroups: Array<TokenGroup>, upstreamTheme: TokenTheme, processedNodes: Array<DTProcessedTokenNode>, preciseCopy?: boolean): TokenTheme;
+    inlineTokens(themeReplica: TokenTheme, tokensInThemeButNotInUpstream: Map<string, DTProcessedTokenNode>): void;
+}

package/build/sdk-typescript/src/tools/design-tokens/utilities/SDKDTTokenGroupTreeMerger.d.ts

@@ -0,0 +1,23 @@
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { Token } from "../../../model/tokens/SDKToken";
+import { TokenTreeElement } from "./tree/SDKDTGroupTree";
+import { DTTokenMergeDiff } from "./SDKDTTokenMerger";
+export type DTTokenTreeMergeDiff = {
+    toUpdate: Array<TokenTreeElement>;
+    toCreate: Array<TokenTreeElement>;
+    toDelete: Array<TokenTreeElement>;
+    toCreateOrUpdate: Array<TokenTreeElement>;
+};
+export type DTGroupMergeDiffElement = {
+    element: TokenTreeElement;
+    childrenIds: Array<string>;
+};
+export type DTGroupMergeDiff = {
+    toUpdate: Array<DTGroupMergeDiffElement>;
+    toCreate: Array<DTGroupMergeDiffElement>;
+    toDelete: Array<TokenTreeElement>;
+};
+/** Utility allowing merging of two distinct token trees */
+export declare class DTTokenGroupTreeMerger {
+    makeGroupsDiff(tokensDiff: DTTokenMergeDiff, existingElements: Array<Token | TokenGroup>): DTGroupMergeDiff;
+}

package/build/sdk-typescript/src/tools/design-tokens/utilities/SDKDTTokenMerger.d.ts

@@ -0,0 +1,16 @@
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { AnyToken } from "../../../model/tokens/SDKTokenValue";
+import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
+export type DTTokenMergeDiff = {
+    toUpdate: Array<DTProcessedTokenNode>;
+    toCreate: Array<DTProcessedTokenNode>;
+    toDelete: Array<DTProcessedTokenNode>;
+    toCreateOrUpdate: Array<DTProcessedTokenNode>;
+};
+/** Utility allowing merging of two pools of tokens */
+export declare class DTTokenMerger {
+    static buildKey(path: Array<string>, name: string): string;
+    buildNodeMap(nodes: Array<DTProcessedTokenNode>): Map<string, DTProcessedTokenNode>;
+    convertBaseTokensToProcessedNode(tokens: Array<AnyToken>, groups: Array<TokenGroup>): Array<DTProcessedTokenNode>;
+    makeTokensDiff(existing: Array<AnyToken>, extracted: Array<DTProcessedTokenNode>, groups: Array<TokenGroup>): DTTokenMergeDiff;
+}

package/build/sdk-typescript/src/tools/design-tokens/utilities/SDKDTTokenReferenceResolver.d.ts

@@ -0,0 +1,48 @@
+import { TokenType } from "../../../model/enums/SDKTokenType";
+import { Token } from "../../../model/tokens/SDKToken";
+import { AnyToken } from "../../../model/tokens/SDKTokenValue";
+import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
+/** Utility allowing resolution of token references */
+export declare class DTTokenReferenceResolver {
+    private mappedTokens;
+    private nodes;
+    replaceRefs(existingToken: AnyToken, newToken: AnyToken): void;
+    addAtomicToken(token: DTProcessedTokenNode, indexOfNewNode: number): void;
+    addAtomicTokens(tokens: Array<DTProcessedTokenNode>): void;
+    unmappedValues(): Array<DTProcessedTokenNode>;
+    tokensOfType(type: TokenType): Array<Token>;
+    lookupReferencedToken(reference: string): Token | undefined;
+    lookupReferencedNode(reference: string): DTProcessedTokenNode | undefined;
+    lookupAllReferencedTokens(reference: string): Array<{
+        token: Token;
+        key: string;
+        location: number;
+        dollarTypeReference: boolean;
+    }> | undefined;
+    replaceAllReferencedTokens(reference: string, replacements: Array<{
+        token: Token;
+        key: string;
+        location: number;
+        dollarTypeReference: boolean;
+    }>): string;
+    replaceToken(base: string, token: Token, key: string, location: number, dollarTypeReference: boolean): string;
+    replaceAt(s: string, what: string, replacement: string, index: number, dollarTypeReference: boolean): string;
+    replacableValue(token: Token): string;
+    isBalancedReference(syntax: string): boolean;
+    valueHasReference(value: string | object | number): boolean;
+    valueIsPureReference(value: string | object): boolean;
+    hasSameNumberOfCharacters(str: string, char1: string, char2: string): boolean;
+    countCharacter(str: string, char: string): number;
+    tokenReferenceKey(path: Array<string>, name: string): string;
+    findBracketStrings(str: string): {
+        index: number;
+        value: string;
+        dollarTypeReference: boolean;
+    }[];
+    findDollarStrings(str: string): {
+        index: number;
+        value: string;
+        dollarTypeReference: boolean;
+    }[];
+    isDollarIdentifier(value: string): boolean;
+}

package/build/sdk-typescript/src/tools/design-tokens/utilities/SDKDTTokenSetResolver.d.ts

@@ -0,0 +1,11 @@
+import { Token } from "../../../model/tokens/SDKToken";
+export type DTProcessedTheme = {
+    sets: Array<DTProcessedTokenSet>;
+};
+export type DTProcessedTokenSet = {
+    tokens: Array<Token>;
+};
+/** Utility allowing merging of two pools of tokens */
+export declare class DTTokenSetResolver {
+    parseTokenSets(sets: any): void;
+}

package/build/sdk-typescript/src/tools/design-tokens/utilities/collection/SDKDTTokenCollection.d.ts

@@ -0,0 +1,13 @@
+import { DTProcessedTokenNode } from "../SDKDTJSONConverter";
+export declare class DTProcessedTokenNodeCollection {
+    readonly index: Map<string, DTProcessedTokenNode>;
+    readonly added: Set<string>;
+    readonly deleted: Map<string, DTProcessedTokenNode>;
+    readonly dirty: Set<string>;
+    readonly list: Array<DTProcessedTokenNode>;
+    constructor(source: Array<DTProcessedTokenNode> | Map<string, DTProcessedTokenNode>);
+    markDeleted(element: DTProcessedTokenNode): void;
+    removeFromCollection(persistentId: string): void;
+    markDirty(node: DTProcessedTokenNode): void;
+    add(node: DTProcessedTokenNode): void;
+}

package/build/sdk-typescript/src/tools/design-tokens/utilities/expression/SDKDTExpressionParser.d.ts

@@ -0,0 +1,5 @@
+/** Parsing and reduction utility for math expressions */
+export declare class DTExpressionParser {
+    /** Reduce value of expressions to their base form */
+    static reduceExpressionsToBaseForm(baseExpression: string): string | number;
+}

package/build/sdk-typescript/src/tools/design-tokens/utilities/tree/SDKDTGroupTree.d.ts

@@ -0,0 +1,12 @@
+import { TokenType } from "../../../../model/enums/SDKTokenType";
+import { TokenGroup } from "../../../../model/groups/SDKTokenGroup";
+import { Token } from "../../../../model/tokens/SDKToken";
+import { GroupTreeNode } from "./SDKDTGroupTreeNode";
+export type GroupTreeNodeWalker = (node: GroupTreeNode, path: GroupTreeNode[]) => void;
+export type TokenTreeElement = Token | TokenGroup;
+export declare class GroupTree extends GroupTreeNode {
+    childType: TokenType;
+    constructor(backingElement: TokenTreeElement);
+    static populate(root: TokenTreeElement, elements: Array<TokenTreeElement>, parentChildrenMap: Map<string, Array<TokenTreeElement>>): GroupTree | null;
+}
+export declare function buildBrandedElementRoots(elements: TokenTreeElement[]): Map<string, Map<TokenType, GroupTree>>;

package/build/sdk-typescript/src/tools/design-tokens/utilities/tree/SDKDTGroupTreeNode.d.ts

@@ -0,0 +1,17 @@
+import { GroupTree, GroupTreeNodeWalker, TokenTreeElement } from "./SDKDTGroupTree";
+export declare class GroupTreeNode {
+    children: GroupTreeNode[];
+    element: TokenTreeElement;
+    tree: GroupTree;
+    get isGroup(): boolean;
+    get name(): string;
+    constructor(element: TokenTreeElement, tree: GroupTree);
+    applyDefaultSorting(): void;
+    protected addChildInternal(child: GroupTreeNode, atIndex?: number): void;
+    protected populate(childrenMap: Map<string, TokenTreeElement[]>): void;
+    private createGroupChild;
+    addChildGroup(groupElement: TokenTreeElement): GroupTreeNode;
+    getOrCreateGroup(path: Array<string>): GroupTreeNode;
+    forEach(callback: GroupTreeNodeWalker, leafsFirst?: boolean): void;
+    private forEachInternal;
+}

package/build/sdk-typescript/src/tools/design-tokens/utilities/tree/SDKDTParentChildMapping.d.ts

@@ -0,0 +1,5 @@
+import { TokenTreeElement } from "./SDKDTGroupTree";
+export declare const MAX_SORT_ORDER: number;
+export declare function buildParentChildrenMap(elements: TokenTreeElement[]): {
+    childrenMap: Map<string, TokenTreeElement[]>;
+};

package/build/sdk-typescript/src/tools/docs-block-builder/SDKDocsBlockBuilder.d.ts

@@ -0,0 +1,409 @@
+import { DocsBlockFigmaNodePropertyOptions, DocsBlockMultiRichTextPropertyOptions } from "../../exports";
+import { DocsBlockDefinition } from "../../model/docs/blocks/definition/SDKDocsBlockDefinition";
+import { DocsBlockItemDefinition } from "../../model/docs/blocks/definition/SDKDocsBlockItemDefinition";
+import { DocsBlockLayout } from "../../model/docs/blocks/definition/SDKDocsBlockLayout";
+import { DocsBlockOnboarding } from "../../model/docs/blocks/definition/SDKDocsBlockOnboarding";
+import { DocsBlockVariant } from "../../model/docs/blocks/definition/SDKDocsBlockVariant";
+import { DocsBlockAssetPropertyDefinition, DocsBlockAssetPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockAssetProperty";
+import { DocsBlockAssetPropertyPropertyDefinition, DocsBlockAssetPropertyPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockAssetPropertyProperty";
+import { DocsBlockBooleanPropertyDefinition, DocsBlockBooleanPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockBooleanProperty";
+import { DocsBlockCodePropertyDefinition, DocsBlockCodePropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockCodeProperty";
+import { DocsBlockCodeSandboxPropertyDefinition, DocsBlockCodeSandboxPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockCodeSandboxProperty";
+import { DocsBlockComponentPropertyDefinition, DocsBlockComponentPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockComponentProperty";
+import { DocsBlockComponentPropertyPropertyDefinition, DocsBlockComponentPropertyPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockComponentPropertyProperty";
+import { DocsBlockDividerPropertyDefinition, DocsBlockDividerPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockDividerProperty";
+import { DocsBlockEmbedUrlPropertyDefinition, DocsBlockEmbedUrlPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockEmbedUrlProperty";
+import { DocsBlockFigmaNodePropertyDefinition } from "../../model/docs/blocks/properties/SDKDocsBlockFigmaNodeProperty";
+import { DocsBlockImagePropertyDefinition, DocsBlockImagePropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockImageProperty";
+import { DocsBlockMarkdownPropertyDefinition, DocsBlockMarkdownPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockMarkdownProperty";
+import { DocsBlockMultiSelectPropertyDefinition, DocsBlockMultiSelectPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockMultiSelectProperty";
+import { DocsBlockNumberPropertyDefinition, DocsBlockNumberPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockNumberProperty";
+import { DocsBlockItemPropertyAnyDefinition } from "../../model/docs/blocks/properties/SDKDocsBlockProperty";
+import { DocsBlockRichTextPropertyDefinition, DocsBlockRichTextPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockRichTextProperty";
+import { DocsBlockSingleSelectPropertyDefinition, DocsBlockSingleSelectPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockSingleSelectProperty";
+import { DocsBlockStorybookPropertyDefinition, DocsBlockStorybookPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockStorybookProperty";
+import { DocsBlockTablePropertyDefinition, DocsBlockTablePropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockTableProperty";
+import { DocsBlockTextPropertyDefinition, DocsBlockTextPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockTextProperty";
+import { DocsBlockTokenPropertyDefinition, DocsBlockTokenPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockTokenProperty";
+import { DocsBlockTokenPropertyPropertyDefinition, DocsBlockTokenPropertyPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockTokenPropertyProperty";
+import { DocsBlockTokenTypePropertyDefinition, DocsBlockTokenTypePropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockTokenTypeProperty";
+import { DocsBlockUrlPropertyDefinition, DocsBlockUrlPropertyOptions } from "../../model/docs/blocks/properties/SDKDocsBlockUrlProperty";
+import { DocsBlockBehaviorDataType } from "../../model/enums/SDKDocsBlockBehaviorDataType";
+import { DocsBlockBehaviorSelectionType } from "../../model/enums/SDKDocsBlockBehaviorSelectionType";
+import { DocsBlockCategory } from "../../model/enums/SDKDocsBlockCategory";
+import { DocsBlockItemVariantLayoutAlign } from "../../model/enums/SDKDocsBlockItemVariantLayoutAlign";
+import { DocsBlockItemVariantLayoutColumnResizing } from "../../model/enums/SDKDocsBlockItemVariantLayoutColumnResizing";
+import { DocsBlockItemVariantLayoutGap } from "../../model/enums/SDKDocsBlockItemVariantLayoutGap";
+export declare class DocsBlockBuilder {
+    /** Create a layout definition with selected properties (or sublayouts) stacked into column */
+    columnLayout(children: Array<DocsBlockItemPropertyAnyDefinition | DocsBlockLayout>, options?: {
+        resizing?: DocsBlockItemVariantLayoutColumnResizing | undefined;
+        align?: DocsBlockItemVariantLayoutAlign | undefined;
+        gap?: DocsBlockItemVariantLayoutGap | undefined;
+    }): DocsBlockLayout;
+    /** Create a layout definition with selected properties (or sublayouts) stacked into row */
+    rowLayout(children: Array<DocsBlockItemPropertyAnyDefinition | DocsBlockLayout>, options?: {
+        gap?: DocsBlockItemVariantLayoutGap | undefined;
+    }): DocsBlockLayout;
+    /** Create an item variant to render the item in a specific way */
+    variantUsingCustomLayout(options: {
+        id: string;
+        name: string;
+        image: string;
+        layout: DocsBlockLayout;
+        description?: string;
+        maxColumns?: number;
+    }): DocsBlockVariant;
+    /** Create and item variant to render the item with default layout (all properties will be stacked into a single column) */
+    variantUsingDefaultLayout(options: {
+        id: string;
+        name: string;
+        image: string;
+        properties: Array<DocsBlockItemPropertyAnyDefinition>;
+        description?: string;
+        maxColumns?: number;
+        appearance?: {
+            isBordered?: boolean;
+            hasBackground?: boolean;
+            isEditorPresentationDifferent?: boolean;
+            showBlockHeaderInEditor?: boolean;
+        };
+    }): DocsBlockVariant;
+    /** Create and item variant to render the item with default layout (all properties will be stacked into a single column) */
+    defaultVariantUsingDefaultLayout(options: {
+        properties: Array<DocsBlockItemPropertyAnyDefinition>;
+        image?: string;
+        description?: string;
+        maxColumns?: number;
+        appearance?: {
+            isBordered?: boolean;
+            hasBackground?: boolean;
+            isEditorPresentationDifferent?: boolean;
+            /** When enabled, the header with block name, description, and header will be displayed
+             * Use only for custom blocks that don't have a good content do be displayed in the editor (e.g. Release notes, Lottie, etc.)
+             * */
+            showBlockHeaderInEditor?: boolean;
+        };
+    }): DocsBlockVariant;
+    /** Create block item with a single variant of rendering */
+    singleVariantItem(configuration: {
+        properties: Array<DocsBlockItemPropertyAnyDefinition>;
+        variant: DocsBlockVariant;
+        appearance?: {
+            isBordered?: boolean;
+            hasBackground?: boolean;
+        };
+    }): DocsBlockItemDefinition;
+    /** Create block item with multiple variants of rendering. The first variant becomes the default one */
+    multiVariantItem(configuration: {
+        properties: Array<DocsBlockItemPropertyAnyDefinition>;
+        variants: Array<DocsBlockVariant>;
+        appearance?: {
+            isBordered?: boolean;
+            hasBackground?: boolean;
+        };
+    }): DocsBlockItemDefinition;
+    /** Creates a core block definition which can't select from Supernova data, and its item can only be created once (Examples: Rich Text, Callout, Heading blocks) */
+    singleItemBlock(configuration: {
+        id: string;
+        name: string;
+        category: DocsBlockCategory;
+        icon: string;
+        description?: string;
+        item: DocsBlockItemDefinition;
+        linkable?: boolean;
+        appearance?: {
+            isBordered?: boolean;
+            hasBackground?: boolean;
+            isEditorPresentationDifferent?: boolean;
+            showBlockHeaderInEditor?: boolean;
+        };
+        searchKeywords?: Array<string>;
+        onboarding?: DocsBlockOnboarding;
+    }): DocsBlockDefinition;
+    /** Creates a core block definition which can't select from Supernova data, and its items can be created multiple times (Examples: Shortcuts block) */
+    multiItemBlock(configuration: {
+        id: string;
+        name: string;
+        category: DocsBlockCategory;
+        icon: string;
+        item: DocsBlockItemDefinition;
+        maxItems?: number;
+        description?: string;
+        linkable?: boolean;
+        appearance?: {
+            isBordered?: boolean;
+            hasBackground?: boolean;
+            isEditorPresentationDifferent?: boolean;
+            showBlockHeaderInEditor?: boolean;
+        };
+        searchKeywords?: Array<string>;
+        onboarding?: DocsBlockOnboarding;
+    }): DocsBlockDefinition;
+    /** Creates a core block definition which will be allowed to select from Supernova data (Examples: Token, Asset block) */
+    dataBlock(configuration: {
+        id: string;
+        name: string;
+        icon: string;
+        category: DocsBlockCategory;
+        item: DocsBlockItemDefinition;
+        dataType: Exclude<DocsBlockBehaviorDataType, DocsBlockBehaviorDataType.item>;
+        selectionType: DocsBlockBehaviorSelectionType;
+        maxSelection?: number;
+        description?: string;
+        linkable?: boolean;
+        appearance?: {
+            isBordered?: boolean;
+            hasBackground?: boolean;
+            isEditorPresentationDifferent?: boolean;
+            showBlockHeaderInEditor?: boolean;
+        };
+        searchKeywords?: Array<string>;
+        onboarding?: DocsBlockOnboarding;
+    }): DocsBlockDefinition;
+    /** Creates onboarding entity */
+    onboarding(configuration: {
+        helpText: string;
+        documentationLink?: string;
+    }): DocsBlockOnboarding;
+    /** Create a block property with type .text and its specific options */
+    textProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockTextPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockTextPropertyOptions;
+        };
+    }): DocsBlockTextPropertyDefinition;
+    /** Create a block property with type .richText and its specific options */
+    richTextProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockRichTextPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockRichTextPropertyOptions;
+        };
+    }): DocsBlockRichTextPropertyDefinition;
+    /** Create a block property with type .richText and its specific options */
+    multiRichTextProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockMultiRichTextPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockMultiRichTextPropertyOptions;
+        };
+    }): DocsBlockRichTextPropertyDefinition;
+    /** Create a block property with type .boolean and its specific options */
+    booleanProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockBooleanPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockBooleanPropertyOptions;
+        };
+    }): DocsBlockBooleanPropertyDefinition;
+    /** Create a block property with type .number and its specific options */
+    numericProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockNumberPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockNumberPropertyOptions;
+        };
+    }): DocsBlockNumberPropertyDefinition;
+    /** Create a block property with type .singleSelect and its specific options */
+    singleSelectProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockSingleSelectPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockSingleSelectPropertyOptions;
+        };
+    }): DocsBlockSingleSelectPropertyDefinition;
+    /** Create a block property with type .multiSelect and its specific options */
+    multiSelectProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockMultiSelectPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockMultiSelectPropertyOptions;
+        };
+    }): DocsBlockMultiSelectPropertyDefinition;
+    /** Create a block property with type .image and its specific options */
+    imageProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options?: DocsBlockImagePropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockImagePropertyOptions;
+        };
+    }): DocsBlockImagePropertyDefinition;
+    /** Create a block property with type .token and its specific options */
+    tokenProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockTokenPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockTokenPropertyOptions;
+        };
+    }): DocsBlockTokenPropertyDefinition;
+    /** Create a block property with type .tokenType and its specific options */
+    tokenTypeProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockTokenTypePropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockTokenTypePropertyOptions;
+        };
+    }): DocsBlockTokenTypePropertyDefinition;
+    /** Create a block property with type .tokenProperty and its specific options */
+    tokenPropertyProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockTokenPropertyPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockTokenPropertyPropertyOptions;
+        };
+    }): DocsBlockTokenPropertyPropertyDefinition;
+    /** Create a block property with type .component and its specific options */
+    componentProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockComponentPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockComponentPropertyOptions;
+        };
+    }): DocsBlockComponentPropertyDefinition;
+    /** Create a block property with type .componentProperty and its specific options */
+    componentPropertyProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockComponentPropertyPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockComponentPropertyPropertyOptions;
+        };
+    }): DocsBlockComponentPropertyPropertyDefinition;
+    /** Create a block property with type .asset and its specific options */
+    assetProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockAssetPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockAssetPropertyOptions;
+        };
+    }): DocsBlockAssetPropertyDefinition;
+    /** Create a block property with type .figmaNodeProperty and its specific options */
+    figmaNodeProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockFigmaNodePropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockFigmaNodePropertyOptions;
+        };
+    }): DocsBlockFigmaNodePropertyDefinition;
+    /** Create a block property with type .assetProperty and its specific options */
+    assetPropertyProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockAssetPropertyPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockAssetPropertyPropertyOptions;
+        };
+    }): DocsBlockAssetPropertyPropertyDefinition;
+    /** Create a block property with type .embedURL and its specific options */
+    embedUrlProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockEmbedUrlPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockEmbedUrlPropertyOptions;
+        };
+    }): DocsBlockEmbedUrlPropertyDefinition;
+    /** Create a block property with type .markdown and its specific options */
+    markdownProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockMarkdownPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockMarkdownPropertyOptions;
+        };
+    }): DocsBlockMarkdownPropertyDefinition;
+    /** Create a block property with type .url and its specific options */
+    urlProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockUrlPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockUrlPropertyOptions;
+        };
+    }): DocsBlockUrlPropertyDefinition;
+    /** Create a block property with type .storybook and its specific options */
+    storybookProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockStorybookPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockStorybookPropertyOptions;
+        };
+    }): DocsBlockStorybookPropertyDefinition;
+    /** Create a block property with type .code and its specific options */
+    codeProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockCodePropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockCodePropertyOptions;
+        };
+    }): DocsBlockCodePropertyDefinition;
+    /** Create a block property with type .codeSandbox and its specific options */
+    codeSandboxProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockCodeSandboxPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockCodeSandboxPropertyOptions;
+        };
+    }): DocsBlockCodeSandboxPropertyDefinition;
+    /** Create a block property with type .table and its specific options */
+    tableProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockTablePropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockTablePropertyOptions;
+        };
+    }): DocsBlockTablePropertyDefinition;
+    /** Create a block property with type .divider and its specific options */
+    dividerProperty(configuration: {
+        id: string;
+        name: string;
+        description?: string;
+        options: DocsBlockDividerPropertyOptions;
+        variants?: {
+            [key: string]: DocsBlockDividerPropertyOptions;
+        };
+    }): DocsBlockDividerPropertyDefinition;
+}