@supernova-studio/supernova-sdk-beta 0.7.17

package/build/sdk-typescript/src/tools/json-builder/SDKToolsJSONBuilder.d.ts

@@ -0,0 +1,58 @@
+import { Supernova } from "../../core/SDKSupernova";
+import { TokenType } from "../../model/enums/SDKTokenType";
+import { TokenGroup } from "../../model/groups/SDKTokenGroup";
+import { Token } from "../../model/tokens/SDKToken";
+export type TokenJSONBuilderOptions = {
+    /** Conversion method to be used for token names. Original will use actual token name */
+    naming: JSONBuilderNamingOption;
+    /** When enabled, brandId will be included in every token */
+    includeBrandId: boolean;
+    /** When enabled, comments will be included in tokens that have description */
+    includeComments: boolean;
+    /** When provided, tokens will be filtered to only show tokens belonging to this brand */
+    brandId: string | null;
+    /** When enabled, type will be included in every token */
+    includeType: boolean;
+    /** When enabled, root category node will be generated. If type === null, multiple root nodes will be generated, one for each type */
+    includeRootTypeNodes: boolean;
+    /** When provided, only tokens of one category will be generated. Providing null will generate all tokens regardless of type */
+    type: TokenType | null;
+    /** When enabled, output will be split into multiple files. Ignored for now */
+    multifile: boolean;
+};
+export type TokenJSONBuilderOptionsInternal = TokenJSONBuilderOptions & {
+    consumerMode: ConsumerMode;
+};
+export declare enum JSONBuilderNamingOption {
+    original = "original",
+    camelcase = "camelcase",
+    snakecase = "snakecase",
+    kebabcase = "kebabcase"
+}
+declare enum ConsumerMode {
+    styleDictionary = 0,
+    figmaTokens = 1
+}
+/** JSON builder tooling object. Allows to build full token JSON definition for different styles of outputs, like Style Dictionary or Figma Tokens plugin */
+export declare class TokenJSONBuilder {
+    private instance;
+    private version;
+    private designSystemId;
+    private versionId;
+    private tokenTransformer;
+    constructor(instance: Supernova, designSystemId: string, versionId: string);
+    /** Fetches all tokens available for selected design system version, and converts them to style dictionary representation. */
+    styleDictionaryRepresentation(options: TokenJSONBuilderOptions): Promise<{}>;
+    /** Fetches all tokens available for selected design system version, and converts them to figma tokens representation. */
+    figmaTokensRepresentation(isSingleFile: boolean): Promise<{}>;
+    private buildTokenStructure;
+    /** Generate style dictionary tree */
+    private generateStyleDictionaryTree;
+    /** Construct tree out of one specific group, independent of tree type */
+    private representTree;
+    /** Find all tokens that belong to a certain group and retrieve them as objects */
+    static tokensOfGroup(containingGroup: TokenGroup, allTokens: Array<Token>): Array<Token>;
+    /** Retrieve chain of groups up to a specified group, ordered from parent to children */
+    static referenceGroupChain(containingGroup: TokenGroup, allGroups: Array<TokenGroup>): Array<TokenGroup>;
+}
+export {};

package/build/sdk-typescript/src/tools/json-builder/elements-transformers/SDKToolsJSONElementFigmaTokensTransformer.d.ts

@@ -0,0 +1,37 @@
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { Token } from "../../../model/tokens/SDKToken";
+import { AnyOptionTokenValue, AnyStringTokenValue, BorderTokenValue, ColorTokenValue, DimensionTokenValue, GradientTokenValue, ShadowTokenValue, TypographyTokenValue } from "../../../model/tokens/SDKTokenValue";
+import { TokenJSONBuilderOptionsInternal } from "../SDKToolsJSONBuilder";
+import { TokenJSONElementTransformer } from "./SDKToolsJSONElementTransformer";
+/** Token transformer that allow generic transform of tokens to different destinations, like Style Dictionary or Figma Tokens representation */
+export declare class TokenJSONElementFigmaTokensTransformer extends TokenJSONElementTransformer {
+    /** Represent color token value either as reference or as plain representation */
+    representColorTokenValue(value: ColorTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent dimension token value either as reference or as plain representation */
+    representDimensionTokenValue(value: DimensionTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent text token value either as reference or as plain representation */
+    representStringTokenValue(value: AnyStringTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representOptionTokenValue(value: AnyOptionTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent typography token value either as reference or as plain representation */
+    representTypographyTokenValue(value: TypographyTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent border token value either as reference or as plain representation */
+    representBorderTokenValue(value: BorderTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent shadow token value either as reference or as plain representation */
+    representShadowTokenValue(values: ShadowTokenValue[], allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent gradient token value either as reference or as plain representation */
+    representGradientTokenValue(values: GradientTokenValue[], allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Retrieve token wrapper containing its metadata and value information (used as container for each defined token) */
+    tokenWrapper(token: Token, value: any, options: TokenJSONBuilderOptionsInternal, groups: Array<TokenGroup>): object;
+    /** Retrieve human-readable token type in unified fashion, used both as token type and as token master group */
+    typeLabelConsideringAbstractGroups(token: Token, groups: Array<TokenGroup>): string | undefined;
+    /** Retrieve wrapper to certain token (referenced by name) pointing to token value */
+    referenceWrapper(reference: string): string;
+    /** Retrieve safe group name made out of normal group name
+     * This replace spaces with dashes, also change anything non-alphanumeric char to it as well.
+     * For example, ST&RK Industries will be changed to st-rk-industries
+     */
+    safeGroupName(group: TokenGroup): string;
+    /** Create full reference name representing token. Such name can, for example, look like: [g1].[g2].[g3].[g4].[token-name] */
+    referenceName(referenceId: string, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): string;
+    groupIsAbstract(group: TokenGroup, allGroups: Array<TokenGroup>): boolean;
+}

package/build/sdk-typescript/src/tools/json-builder/elements-transformers/SDKToolsJSONElementStyleDictionaryTransformer.d.ts

@@ -0,0 +1,26 @@
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { Token } from "../../../model/tokens/SDKToken";
+import { AnyOptionTokenValue, AnyStringTokenValue, BorderTokenValue, ColorTokenValue, DimensionTokenValue, GradientTokenValue, ShadowTokenValue, TypographyTokenValue } from "../../../model/tokens/SDKTokenValue";
+import { TokenJSONBuilderOptionsInternal } from "../SDKToolsJSONBuilder";
+import { TokenJSONElementTransformer } from "./SDKToolsJSONElementTransformer";
+/** Token transformer that allow generic transform of tokens to different destinations, like Style Dictionary or Figma Tokens representation */
+export declare class TokenJSONElementStyleDictionaryTransformer extends TokenJSONElementTransformer {
+    /** Represent color token value either as reference or as plain representation */
+    representColorTokenValue(value: ColorTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent dimension token value either as reference or as plain representation */
+    representDimensionTokenValue(value: DimensionTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent text token value either as reference or as plain representation */
+    representStringTokenValue(value: AnyStringTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representOptionTokenValue(value: AnyOptionTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent typography token value either as reference or as plain representation */
+    representTypographyTokenValue(value: TypographyTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent border token value either as reference or as plain representation */
+    representBorderTokenValue(value: BorderTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent shadow token value either as reference or as plain representation */
+    representShadowTokenValue(values: ShadowTokenValue[], allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent gradient token value either as reference or as plain representation */
+    representGradientTokenValue(values: GradientTokenValue[], allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Retrieve wrapper to certain token (referenced by name) pointing to token value */
+    referenceWrapper(reference: string): string;
+    groupIsAbstract(group: TokenGroup): boolean;
+}

package/build/sdk-typescript/src/tools/json-builder/elements-transformers/SDKToolsJSONElementTransformer.d.ts

@@ -0,0 +1,68 @@
+import { TokenType } from "../../../model/enums/SDKTokenType";
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { BorderToken } from "../../../model/tokens/SDKBorderToken";
+import { ColorToken } from "../../../model/tokens/SDKColorToken";
+import { AnyDimensionToken } from "../../../model/tokens/SDKDimensionToken";
+import { GradientToken } from "../../../model/tokens/SDKGradientToken";
+import { ShadowToken } from "../../../model/tokens/SDKShadowToken";
+import { AnyStringToken } from "../../../model/tokens/SDKStringToken";
+import { Token } from "../../../model/tokens/SDKToken";
+import { AnyDimensionTokenValue, AnyOptionToken, AnyOptionTokenValue, AnyStringTokenValue, BorderTokenValue, ColorTokenValue, GradientTokenValue, ShadowTokenValue, TypographyTokenValue } from "../../../model/tokens/SDKTokenValue";
+import { TypographyToken } from "../../../model/tokens/SDKTypographyToken";
+import { JSONBuilderNamingOption, TokenJSONBuilderOptionsInternal } from "../SDKToolsJSONBuilder";
+/** Token transformer that allow generic transform of tokens to different destinations, like Style Dictionary or Figma Tokens representation */
+export declare class TokenJSONElementTransformer {
+    /** Represent a singular token as SD object */
+    representToken(token: Token, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): object;
+    /** Represent full color token, including wrapping meta-information such as user description */
+    representColorToken(token: ColorToken, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): object;
+    /** Represent full border token, including wrapping meta-information such as user description */
+    representBorderToken(token: BorderToken, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): object;
+    /** Represent full gradient token, including wrapping meta-information such as user description */
+    representGradientToken(token: GradientToken, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): object;
+    /** Represent full dimension token, including wrapping meta-information such as user description */
+    representDimensionToken(token: AnyDimensionToken, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent full shadow token, including wrapping meta-information such as user description */
+    representShadowToken(token: ShadowToken, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): object;
+    /** Represent full text token, including wrapping meta-information such as user description */
+    representStringToken(token: AnyStringToken, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    representOptionToken(token: AnyOptionToken, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent full typography token, including wrapping meta-information such as user description */
+    representTypographyToken(token: TypographyToken, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): object;
+    /** Represent color token value either as reference or as plain representation */
+    representColorTokenValue(value: ColorTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent dimension token value either as reference or as plain representation */
+    representDimensionTokenValue(value: AnyDimensionTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent text token value either as reference or as plain representation */
+    representStringTokenValue(value: AnyStringTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representOptionTokenValue(value: AnyOptionTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent typography token value either as reference or as plain representation */
+    representTypographyTokenValue(value: TypographyTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent border token value either as reference or as plain representation */
+    representBorderTokenValue(value: BorderTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent shadow token value either as reference or as plain representation */
+    representShadowTokenValue(values: ShadowTokenValue[], allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent gradient token value either as reference or as plain representation */
+    representGradientTokenValue(value: GradientTokenValue[], allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Retrieve wrapper to certain token (referenced by name) pointing to token value */
+    referenceWrapper(reference: string, options: TokenJSONBuilderOptionsInternal): void;
+    /** Retrieve token wrapper containing its metadata and value information (used as container for each defined token) */
+    tokenWrapper(token: Token, value: any, options: TokenJSONBuilderOptionsInternal, groups: Array<TokenGroup>): object;
+    /** Create full reference name representing token. Such name can, for example, look like: [g1].[g2].[g3].[g4].[token-name] */
+    referenceName(referenceId: string, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): string;
+    /** Retrieve safe token name made out of normal token name
+     * This replace spaces with dashes, also change anything non-alphanumeric char to it as well.
+     * For example, ST&RK Industries will be changed to st-rk-industries
+     */
+    safeTokenName(token: Token, naming: JSONBuilderNamingOption): string;
+    /** Retrieve safe group name made out of normal group name
+     * This replace spaces with dashes, also change anything non-alphanumeric char to it as well.
+     * For example, ST&RK Industries will be changed to st-rk-industries
+     */
+    safeGroupName(group: TokenGroup): string;
+    processedName(name: string, naming: JSONBuilderNamingOption): string;
+    /** Retrieve human-readable token type in unified fashion, used both as token type and as token master group */
+    typeLabel(type: TokenType): "color" | "gradient" | "typography" | "border" | "textCase" | "textDecoration" | "visibility" | "text" | "shadow" | "measure" | undefined;
+    /** Retrieve chain of groups up to a specified group, ordered from parent to children */
+    referenceGroupChain(containingGroup: TokenGroup, allGroups: Array<TokenGroup>): Array<TokenGroup>;
+}

package/build/sdk-typescript/src/tools/markdown-transform/SDKToolsMarkdownTransform.d.ts

@@ -0,0 +1,22 @@
+import { Supernova } from "../../core/SDKSupernova";
+import { DocumentationLegacyPage } from "../../model/documentation/SDKDocumentationLegacyPage";
+import { DocumentationLegacyPageBlockType } from "../../model/enums/SDKDocumentationLegacyPageBlockType";
+import { MarkdownTransformBlock } from "./SDKToolsMarkdownTransformBlock";
+/** Output markdown mode. Commonmark and GitHub is currently supported */
+export declare enum MarkdownTransformType {
+    commonmark = "commonmark",
+    github = "github"
+}
+/** Markdown transformers */
+export declare class MarkdownTransform {
+    conversionType: MarkdownTransformType;
+    blockTransformer: MarkdownTransformBlock;
+    constructor(type: MarkdownTransformType, instance: Supernova, designSystemId: string, workspaceId: string, versionId: string);
+    /** Converts entire definition of the page, including its metadata like title and description, to markdown */
+    convertPageToMarkdown(page: DocumentationLegacyPage): Promise<string>;
+    /** Creates flattened structure of the blocks, even from the contained blocks, so it is easier to iterate through them */
+    private flattenedBlocksOfPage;
+    /** Flattens one leaf of blocks */
+    private flattenedBlocksOfBlock;
+    isContainer(blockType: DocumentationLegacyPageBlockType): boolean;
+}

package/build/sdk-typescript/src/tools/markdown-transform/SDKToolsMarkdownTransformBlock.d.ts

@@ -0,0 +1,75 @@
+import { Supernova } from "../../core/SDKSupernova";
+import { DocumentationLegacyPage } from "../../model/documentation/SDKDocumentationLegacyPage";
+import { DocumentationLegacyPageBlock } from "../../model/documentation/SDKDocumentationLegacyPageBlock";
+import { DocumentationLegacyPageBlockAssets } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockAssets";
+import { DocumentationLegacyPageBlockCallout } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockCallout";
+import { DocumentationLegacyPageBlockCode } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockCode";
+import { DocumentationLegacyPageBlockColumn } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockColumn";
+import { DocumentationLegacyPageBlockColumnItem } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockColumnItem";
+import { DocumentationLegacyPageBlockEmbedFigma } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockEmbedFigma";
+import { DocumentationLegacyPageBlockEmbedGeneric } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockEmbedGeneric";
+import { DocumentationLegacyPageBlockEmbedLink } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockEmbedLink";
+import { DocumentationLegacyPageBlockEmbedStorybook } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockEmbedStorybook";
+import { DocumentationLegacyPageBlockEmbedYoutube } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockEmbedYoutube";
+import { DocumentationLegacyPageBlockFrames } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockFrames";
+import { DocumentationLegacyPageBlockHeading } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockHeading";
+import { DocumentationLegacyPageBlockImage } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockImage";
+import { DocumentationLegacyPageOrderedList } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockOrderedList";
+import { DocumentationLegacyPageBlockQuote } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockQuote";
+import { DocumentationLegacyPageBlockRenderCode } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockRenderCode";
+import { DocumentationLegacyPageBlockShortcuts } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockShortcuts";
+import { DocumentationLegacyPageBlockTab } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockTab";
+import { DocumentationLegacyPageBlockTabItem } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockTabItem";
+import { DocumentationLegacyPageBlockTable } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockTable";
+import { DocumentationLegacyPageBlockTableCell } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockTableCell";
+import { DocumentationLegacyPageBlockText } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockText";
+import { DocumentationLegacyPageBlockToken } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockToken";
+import { DocumentationLegacyPageBlockTokenGroup } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockTokenGroup";
+import { DocumentationLegacyPageBlockTokenList } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockTokenList";
+import { DocumentationLegacyPageUnorderedList } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockUnorderedList";
+import { MarkdownTransformType } from "./SDKToolsMarkdownTransform";
+/** Markdown block transformer */
+export declare class MarkdownTransformBlock {
+    private transformType;
+    private utilTransformer;
+    private instance;
+    private designSystemId;
+    private versionId;
+    private workspaceId;
+    newlineSeparator: string;
+    constructor(type: MarkdownTransformType, instance: Supernova, designSystemId: string, workspaceId: string, versionId: string);
+    /** Converts a single block - depending on the type - to a markdown definition of specific type */
+    convertBlockToMarkdown(block: DocumentationLegacyPageBlock, pageContext: DocumentationLegacyPage): Promise<string | null>;
+    convertHeadingBlock(block: DocumentationLegacyPageBlockHeading): string | null;
+    convertCalloutBlock(block: DocumentationLegacyPageBlockCallout): string | null;
+    convertQuoteBlock(block: DocumentationLegacyPageBlockQuote): string | null;
+    convertDividerBlock(): string | null;
+    convertImageBlock(block: DocumentationLegacyPageBlockImage): string | null;
+    convertOrderedListBlock(block: DocumentationLegacyPageOrderedList): string | null;
+    convertUnorderedListBlock(block: DocumentationLegacyPageUnorderedList): string | null;
+    convertLiveCodeBlock(block: DocumentationLegacyPageBlockRenderCode): string | null;
+    convertCodeBlock(block: DocumentationLegacyPageBlockCode): string | null;
+    convertTextBlock(block: DocumentationLegacyPageBlockText): string | null;
+    convertGenericEmbedBlock(block: DocumentationLegacyPageBlockEmbedGeneric): string | null;
+    convertStorybookEmbedBlock(block: DocumentationLegacyPageBlockEmbedStorybook): string | null;
+    convertLinkBlock(block: DocumentationLegacyPageBlockEmbedLink): string | null;
+    convertYoutubeEmbedBlock(block: DocumentationLegacyPageBlockEmbedYoutube): string | null;
+    convertFigmaEmbedBlock(block: DocumentationLegacyPageBlockEmbedFigma): string | null;
+    convertTokenBlock(block: DocumentationLegacyPageBlockToken): Promise<string | null>;
+    convertTokenListBlock(block: DocumentationLegacyPageBlockTokenList): Promise<string | null>;
+    convertTokenGroupBlock(block: DocumentationLegacyPageBlockTokenGroup): Promise<string | null>;
+    private flattenedGroupsFromRoot;
+    convertComponentAssetBlock(block: DocumentationLegacyPageBlockAssets): Promise<string | null>;
+    convertFigmaFramesBlock(block: DocumentationLegacyPageBlockFrames): string | null;
+    convertShortcutsBlock(block: DocumentationLegacyPageBlockShortcuts, pageContext: DocumentationLegacyPage): Promise<string | null>;
+    private relativePathToPage;
+    convertTableBlock(block: DocumentationLegacyPageBlockTable, pageContext: DocumentationLegacyPage): Promise<string | null>;
+    convertTableRowBlock(): string | null;
+    convertTableCellBlock(block: DocumentationLegacyPageBlockTableCell, pageContext: DocumentationLegacyPage): Promise<string | null>;
+    convertTabsBlock(block: DocumentationLegacyPageBlockTab, pageContext: DocumentationLegacyPage): Promise<string | null>;
+    convertTabItemBlock(block: DocumentationLegacyPageBlockTabItem, pageContext: DocumentationLegacyPage): Promise<string | null>;
+    convertColumnBlock(block: DocumentationLegacyPageBlockColumn, pageContext: DocumentationLegacyPage): Promise<string | null>;
+    convertColumnItemBlock(block: DocumentationLegacyPageBlockColumnItem, pageContext: DocumentationLegacyPage): Promise<string | null>;
+    convertCustomBlock(): string | null;
+    convertURLBlock(block: DocumentationLegacyPageBlockEmbedGeneric, userAction: string): string | null;
+}

package/build/sdk-typescript/src/tools/markdown-transform/SDKToolsMarkdownTransformUtil.d.ts

@@ -0,0 +1,22 @@
+import { DocumentationLegacyRichText } from "../../model/documentation/SDKDocumentationLegacyRichText";
+import { DocumentationLegacyPageBlockText } from "../../model/documentation/blocks/SDKDocumentationLegacyPageBlockText";
+import { Token } from "../../model/tokens/SDKToken";
+/** Markdown block transformer */
+export declare class MarkdownTransformUtil {
+    private tokenTransformer;
+    constructor();
+    /** Converts rich text block to markdown
+     *
+     * This is very naive implementation and will break in complicated cases, like double control characters of the same type next to each other
+     * Must improve later with something more sophisticated, ideally tree builder with branched resolution.
+     */
+    convertTextBlockToMarkdown(block: DocumentationLegacyPageBlockText): string | null;
+    /** Converts rich text to markdown
+     *
+     * This is very naive implementation and will break in complicated cases, like double control characters of the same type next to each other
+     * Must improve later with something more sophisticated, ideally tree builder with branched resolution.
+     */
+    convertRichTextToMarkdown(richText: DocumentationLegacyRichText): string;
+    /** Convert token to markdown representation */
+    convertTokenToMarkdown(token: Token): string;
+}

package/build/sdk-typescript/src/tools/search-index/SDKToolsDocSearch.d.ts

@@ -0,0 +1,47 @@
+import { DocumentationLegacyPage } from "../../model/documentation/SDKDocumentationLegacyPage";
+import Fuse from "fuse.js";
+export declare enum DocSearchResultDataType {
+    contentBlock = "contentBlock",
+    sectionHeader = "sectionHeader",
+    pageTitle = "pageTitle"
+}
+export type DocSearchResult = {
+    item: DocSearchResultData;
+    refIndex: number;
+};
+export type DocSearchResultData = {
+    id: number;
+    pageName: string;
+    pageId: string;
+    blockId: string | undefined;
+    text: string;
+    type: DocSearchResultDataType;
+};
+export type DocSearchConfiguration = {
+    shouldSort?: boolean;
+    threshold?: number;
+    location?: number;
+    distance?: number;
+    maxPatternLength?: number;
+    minMatchCharLength?: number;
+    ignoreLocation?: boolean;
+    keys: Array<string>;
+};
+/** Search manager */
+export declare class DocSearch {
+    searchEngine: Fuse<object>;
+    searchConfiguration: DocSearchConfiguration;
+    constructor(configuration: DocSearchConfiguration);
+    updateSearchIndex: (pages: Array<DocumentationLegacyPage>) => Array<DocSearchResultData>;
+    search: (input: string) => Array<DocSearchResult>;
+    /** When using this configuration, the results will be very precise and will not be deviating too much from the query */
+    static defaultPreciseConfiguration(): DocSearchConfiguration;
+    /** When using this configuration, the results will be more fuzzy and might cover broader spectrum results than just near-keyword based search */
+    static defaultFuzzyConfiguration(): DocSearchConfiguration;
+    /** Reconstructs the search index */
+    private reconstructSearchIndex;
+    /** Creates flattened structure of the blocks, even from the contained blocks, so it is easier to iterate through them */
+    private flattenedBlocksOfPage;
+    /** Flattens one leaf of blocks */
+    private flattenedBlocksOfBlock;
+}

package/build/sdk-typescript/src/tools/token-preview/TokenUtilPreviewGenerator.d.ts

@@ -0,0 +1,20 @@
+import { Token } from "../../model/tokens/SDKToken";
+import { AnyMultiLayerToken, AnySingleLayerToken } from "../../model/tokens/SDKTokenValue";
+import { TokenUtilPreviewMetadata, TokenUtilPreviewReferenceInfo, TokenUtilPreviewResolvedStyle, TokenUtilPreviewTokenType, TokenUtilPreviewTokenValueSegment } from "./TokenUtilPreviewTypes";
+export declare class TokenUtilPreviewGenerator {
+    /** Generates segments required for rendering of the preview. Only usable with Supernova preview */
+    static tokenPreviewSegments(token: Token, allTokens: Map<string, Token>): Array<TokenUtilPreviewTokenValueSegment | "separator">;
+    /** Generates metadata required for rendering of the preview. Only usable with Supernova preview */
+    static tokenPreviewMetadata(token: Token, allTokens: Map<string, Token>): TokenUtilPreviewMetadata;
+    /** Generates style required for rendering of the preview. Only usable with Supernova preview */
+    static tokenPreviewStyle(token: Token, overridenStyles?: {
+        fontFamily?: string;
+        fontWeight?: string;
+    }): TokenUtilPreviewResolvedStyle;
+    /** Generates adjusted preview type required for rendering of the preview. Only usable with Supernova preview */
+    static tokenPreviewType(token: Token): TokenUtilPreviewTokenType;
+    /** Generates per-value description of passed token. Only usable with Supernova preview */
+    static tokenReferenceInfoForSingleLayerToken(token: AnySingleLayerToken, allTokens: Map<string, Token>): TokenUtilPreviewReferenceInfo;
+    /** Generates per-value description of passed token. Only usable with Supernova preview */
+    static tokenReferenceInfoForMultiLayerToken(token: AnyMultiLayerToken, layerIndex: number, allTokens: Map<string, Token>): TokenUtilPreviewReferenceInfo;
+}

package/build/sdk-typescript/src/tools/token-preview/TokenUtilPreviewMetadataGenerator.d.ts

@@ -0,0 +1,8 @@
+import { TokenType } from "../../model/enums/SDKTokenType";
+import { Token } from "../../model/tokens/SDKToken";
+import { TokenUtilPreviewMetadata, TokenUtilPreviewTokenType } from "./TokenUtilPreviewTypes";
+export declare class TokenUtilPreviewMetadataGenerator {
+    resolvedMetadataForToken(token: Token, allTokens: Map<string, Token>): TokenUtilPreviewMetadata;
+    displayValue(token: Token): string;
+    tokenTypeToPreviewType(type: TokenType): TokenUtilPreviewTokenType;
+}

package/build/sdk-typescript/src/tools/token-preview/TokenUtilPreviewReferenceInfoGenerator.d.ts

@@ -0,0 +1,9 @@
+import { Token } from "../../model/tokens/SDKToken";
+import { AnyMultiLayerToken } from "../../model/tokens/SDKTokenValue";
+import { TokenUtilPreviewReferenceInfo } from "./TokenUtilPreviewTypes";
+export declare class TokenUtilPreviewReferenceInfoGenerator {
+    resolvedInfoForSingleLayerToken(token: Token, allTokens: Map<string, Token>): TokenUtilPreviewReferenceInfo;
+    resolvedInfoForMultiLayerToken(token: AnyMultiLayerToken, layerIndex: number, allTokens: Map<string, Token>): TokenUtilPreviewReferenceInfo;
+    private label;
+    private textDecorationToString;
+}

package/build/sdk-typescript/src/tools/token-preview/TokenUtilPreviewSegmentGenerator.d.ts

@@ -0,0 +1,7 @@
+import { Token } from "../../model/tokens/SDKToken";
+import { ShadowTokenValue } from "../../model/tokens/SDKTokenValue";
+import { TokenUtilPreviewTokenValueSegment } from "./TokenUtilPreviewTypes";
+export declare class TokenUtilPreviewSegmentGenerator {
+    static resolvedSegmentsForToken(token: Token, allTokens: Map<string, Token>): Array<TokenUtilPreviewTokenValueSegment | "separator">;
+    static shadowValuesToSegments(layer: ShadowTokenValue | null, allTokens: Map<string, Token>): Array<TokenUtilPreviewTokenValueSegment | "separator">;
+}

package/build/sdk-typescript/src/tools/token-preview/TokenUtilPreviewStyleGenerator.d.ts

@@ -0,0 +1,8 @@
+import { Token } from "../../model/tokens/SDKToken";
+import { TokenUtilPreviewResolvedStyle } from "./TokenUtilPreviewTypes";
+export declare class TokenUtilPreviewStyleGenerator {
+    resolvedStyleForToken(token: Token, overridenStyles?: {
+        fontFamily?: string;
+        fontWeight?: string;
+    }): TokenUtilPreviewResolvedStyle | undefined;
+}

package/build/sdk-typescript/src/tools/token-preview/TokenUtilPreviewTypes.d.ts

@@ -0,0 +1,68 @@
+export type TokenUtilPreviewTokenValueSegment = {
+    value: string;
+    referencedName?: string;
+    prefersReferenceName?: boolean;
+};
+export type TokenUtilPreviewTokenType = "blur" | "border" | "borderWidth" | "color" | "copy" | "fontFamily" | "fontSize" | "fontWeight" | "dimension" | "duration" | "gradient" | "lineHeight" | "letterSpacing" | "opacity" | "paragraphSpacing" | "radius" | "shadow" | "size" | "space" | "string" | "textCase" | "textDecoration" | "typography" | "visibility" | "zIndex";
+export type TokenUtilPreviewMetadata = {
+    displayValue: string;
+    referencedTo?: string;
+    tokenType: TokenUtilPreviewTokenType;
+} & ({
+    meta?: null;
+} | TokenUtilPreviewShadowTokenPreview | TokenUtilPreviewTypographyTokenPreview | TokenUtilPreviewDimensionTokenPreview | TokenUtilPreviewBlurTokenPreview);
+export type TokenUtilPreviewShadowTokenPreview = {
+    meta: ShadowTokenMetadata;
+};
+export type TokenUtilPreviewTypographyTokenPreview = {
+    meta: TypographyTokenMetadata;
+};
+export type TokenUtilPreviewDimensionTokenPreview = {
+    meta: DimensionTokenMetadata;
+};
+export type TokenUtilPreviewBlurTokenPreview = {
+    meta: BlurTokenMetadata;
+};
+export type TokenUtilPreviewResolvedStyle = {
+    background?: string;
+    blur?: string;
+    borderStyle?: "solid" | "dashed" | "dotted";
+    borderWidth?: string;
+    borderColor?: string;
+    borderRadius?: string;
+    boxShadow?: string;
+    fontFamily?: string;
+    fontSize?: string;
+    fontWeight?: string;
+    letterSpacing?: string;
+    lineHeight?: string;
+    opacity?: string;
+    textTransform?: string;
+    textDecoration?: string;
+    width?: string;
+};
+export type ShadowTokenMetadata = {
+    x: number;
+    y: number;
+    type: "inner" | "drop";
+};
+export type TypographyTokenMetadata = {
+    fontSize: DimensionTokenMetadata;
+};
+export type DimensionTokenMetadata = {
+    value: number;
+    unit: string;
+};
+export type BlurTokenMetadata = {
+    type: "layer" | "background";
+};
+export type TokenUtilPreviewReferenceInfo = {
+    alwaysShown: Array<TokenUtilPreviewReferenceInfoPiece>;
+    optionallyShown: Array<TokenUtilPreviewReferenceInfoPiece>;
+};
+export type TokenUtilPreviewReferenceInfoPiece = {
+    key?: Array<TokenUtilPreviewTokenValueSegment>;
+    value?: Array<TokenUtilPreviewTokenValueSegment>;
+    icon?: string;
+    fullWidth?: boolean;
+};

package/build/sdk-typescript/src/tools/token-transform/SDKToolsTokenTransform.d.ts

@@ -0,0 +1,42 @@
+import { ColorToken } from "../../model/tokens/SDKColorToken";
+import { Token } from "../../model/tokens/SDKToken";
+import { AnyDimensionTokenValue, AnyOptionTokenValue, AnyStringTokenValue, BlurTokenValue, BorderTokenValue, ColorTokenValue, GradientTokenValue, ShadowTokenValue, TypographyTokenValue } from "../../model/tokens/SDKTokenValue";
+/** Token data transformer. Use for direct representation of token to other representations, such as CSS, rgb etc. More transformers will be added over time */
+export declare class TokenTransform {
+    /** Converts a single token to CSS definition. Values are always resolved to plain values, references to other tokens are not yet supported */
+    tokenToCSS(token: Token): string;
+    /** Converts token to appropriate css variable definition --(name): css_definition */
+    tokenToCSSVariableDeclaration(token: Token, variableName: string): string;
+    /** Converts color token value to css definition */
+    colorTokenToCSS(value: ColorTokenValue, dedicatedOpacity?: number): string;
+    /** Converts border token value to css definition */
+    borderTokenToCSS(value: BorderTokenValue): string;
+    /** Converts shadow token and opacity by merging two opacities and using color token opacity as fallback */
+    shadowTokenColorAndOpacityToCSS(value: ShadowTokenValue): string;
+    /** Converts shadow token value to css definition */
+    shadowsTokenToCSS(value: ShadowTokenValue[]): string;
+    shadowTokenToCSS(value: ShadowTokenValue): string;
+    /** Converts typography token value to css definition */
+    typographyTokenToCSS(value: TypographyTokenValue): string;
+    /** Converts border token value to css definition */
+    blurTokenToCSS(value: BlurTokenValue): string;
+    /** Converts border token value to css definition */
+    dimensionTokenToCSS(value: AnyDimensionTokenValue): string;
+    private unitToCSS;
+    gradientsTokenToCSS(value: GradientTokenValue[]): string;
+    /** Converts gradient token value to css definition */
+    gradientTokenToCSS(value: GradientTokenValue): string;
+    /** Converts generic token value to css definition */
+    stringTokenToCSS(value: AnyStringTokenValue): string;
+    optionTokenToCSS(value: AnyOptionTokenValue): string;
+    /** Converts a single color token to #hheexx or #hheexxaa */
+    colorTokenToHEXorHEXA(colorToken: ColorToken): string;
+    /** Converts a single color token to rgba(x,x,x,x)  */
+    colorTokenToRGBA(colorToken: ColorToken): string;
+    /** Converts a single color token to rgba(x,x,x,x) with relative values */
+    colorTokenToPercenageRGBA(colorToken: ColorToken): string;
+    /** Converts a single color token to hsla(x,x,x,x) */
+    colorTokenToHSLA(colorToken: ColorToken): string;
+    /** Converts a single color token to hsva(x,x,x,x) */
+    colorTokenToHSVA(colorToken: ColorToken): string;
+}

package/build/sdk-typescript/src/utils/CommonUtils.d.ts

@@ -0,0 +1,5 @@
+export declare function castEnum<O extends string>(value: `${O}`): O;
+export declare function castOptionalEnum<O extends string>(value: `${O}` | undefined): O | undefined;
+export type NonEmptyArray<T> = [T, ...T[]];
+export declare function sureOf<T>(entity: T | null | undefined): NonNullable<T>;
+export declare function sortUsingMap<T, K>(items: Array<T>, indexes: Map<K, number>, keyFn: (item: T) => K): Array<T>;

package/build/sdk-typescript/src/utils/ComponentUtils.d.ts

@@ -0,0 +1,12 @@
+import { Component } from "../model/components/SDKComponent";
+import { ComponentGroup } from "../model/groups/SDKComponentGroup";
+export declare class ComponentUtils {
+    /** Map components for lookup */
+    static componentsToReferenceMap(components: Array<Component>): Map<string, Component>;
+    /** Map component groups for lookup */
+    static componentGroupsToReferenceMap(groups: Array<ComponentGroup>): Map<string, ComponentGroup>;
+    /** Creates a new component group. Default values will be used for all properties */
+    static createDefaultComponentGroup(versionId: string, brandId: string, name?: string): ComponentGroup;
+    /** Creates a new component. Default values will be used for all properties */
+    static createDefaultComponent(versionId: string, brandId: string, name?: string): Component;
+}

package/build/sdk-typescript/src/utils/FlowUtils.d.ts

@@ -0,0 +1,5 @@
+export declare class FlowUtils {
+    static offsetLines(content: string, by: number, character: string): string;
+    static offsetLinesIgnoreFirst(content: string, by: number, character: string): string;
+    static offsetLinesCanIgnoreFirstline(content: string, shouldIgnoreFirstLine: boolean, userOffset: number, nodeOffset: number, character: string): string;
+}