@supernova-studio/supernova-sdk-beta 1.6.10

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

@@ -0,0 +1,17 @@
+import { Token } from '../../../model/tokens/SDKToken';
+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 {
+    constructor();
+    static buildKey(path: Array<string>, name: string): string;
+    buildPath(token: Token): Array<string>;
+    buildNodeMap(nodes: Array<DTProcessedTokenNode>): Map<string, DTProcessedTokenNode>;
+    convertBaseTokensToProcessedNode(tokens: Array<Token>): Array<DTProcessedTokenNode>;
+    makeTokensDiff(existing: Array<Token>, extracted: Array<DTProcessedTokenNode>): DTTokenMergeDiff;
+}

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

@@ -0,0 +1,37 @@
+import { AnyToken } from '../../../model/tokens/SDKTokenValue';
+import { Token } from '../../../model/tokens/SDKToken';
+import { DTProcessedTokenNode } from './SDKDTJSONConverter';
+/** Utility allowing resolution of token references */
+export declare class DTTokenReferenceResolver {
+    private mappedTokens;
+    private nodes;
+    constructor();
+    replaceRefs(existingToken: AnyToken, newToken: AnyToken): void;
+    addAtomicToken(token: DTProcessedTokenNode): void;
+    addAtomicTokens(tokens: Array<DTProcessedTokenNode>): void;
+    unmappedValues(): Array<DTProcessedTokenNode>;
+    lookupReferencedToken(reference: string): Token | undefined;
+    lookupAllReferencedTokens(reference: string): Array<{
+        token: Token;
+        key: string;
+        location: number;
+    }> | undefined;
+    replaceAllReferencedTokens(reference: string, replacements: Array<{
+        token: Token;
+        key: string;
+        location: number;
+    }>): string;
+    replaceToken(base: string, token: Token, key: string, location: number): string;
+    replaceAt(s: string, what: string, replacement: string, index: number): 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;
+    }[];
+}

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

@@ -0,0 +1,12 @@
+import { Token } from "../../..";
+export type DTProcessedTheme = {
+    sets: Array<DTProcessedTokenSet>;
+};
+export type DTProcessedTokenSet = {
+    tokens: Array<Token>;
+};
+/** Utility allowing merging of two pools of tokens */
+export declare class DTTokenSetResolver {
+    constructor();
+    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,10 @@
+import { Token, TokenGroup, TokenType } from '../../../..';
+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;
+}
+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,20 @@
+import { Token, TokenGroup } from '../../../..';
+import { GroupTree } from './SDKDTGroupTree';
+export type GroupTreeNodeWalker = (node: GroupTreeNode, path: GroupTreeNode[]) => void;
+export type TokenTreeElement = Token | TokenGroup;
+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 "./SDKDTGroupTreeNode";
+export declare const MAX_SORT_ORDER: number;
+export declare function buildParentChildrenMap(elements: TokenTreeElement[]): {
+    childrenMap: Map<string, TokenTreeElement[]>;
+};

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

@@ -0,0 +1,57 @@
+import { DesignSystemVersion } from "../../core/SDKDesignSystemVersion";
+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 tokenTransformer;
+    constructor(instance: Supernova, version: DesignSystemVersion);
+    /** Fetches all tokens available for selected design system version, and converts them to style dictionary representation. */
+    styleDictionaryRepresentation(options: TokenJSONBuilderOptions): Promise<Object>;
+    /** Fetches all tokens available for selected design system version, and converts them to figma tokens representation. */
+    figmaTokensRepresentation(isSingleFile: boolean): Promise<Object>;
+    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): Array<TokenGroup>;
+}
+export {};

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

@@ -0,0 +1,40 @@
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { Token } from "../../../model/tokens/SDKToken";
+import { BorderTokenValue, ColorTokenValue, FontTokenValue, GradientTokenValue, MeasureTokenValue, RadiusTokenValue, ShadowTokenValue, TextTokenValue, TypographyTokenValue } from "../../../model/tokens/SDKTokenValue";
+import { JSONBuilderNamingOption, 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: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent radius token value either as reference or as plain representation */
+    representRadiusTokenValue(value: RadiusTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent measure token value either as reference or as plain representation */
+    representMeasureTokenValue(value: MeasureTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent font token value either as reference or as plain representation */
+    representFontTokenValue(value: FontTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent text token value either as reference or as plain representation */
+    representTextTokenValue(value: TextTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent typography token value either as reference or as plain representation */
+    representTypographyTokenValue(value: TypographyTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent border token value either as reference or as plain representation */
+    representBorderTokenValue(value: BorderTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent shadow token value either as reference or as plain representation */
+    representShadowTokenValue(value: ShadowTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent gradient token value either as reference or as plain representation */
+    representGradientTokenValue(value: GradientTokenValue, allTokens: Array<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): Object;
+    /** Retrieve human-readable token type in unified fashion, used both as token type and as token master group */
+    typeLabelConsideringAbstractGroups(token: Token): "border" | "color" | "fontSize" | "letterSpacing" | "lineHeight" | "paragraphSpacing" | "font" | "gradient" | "radius" | "shadow" | "text" | "typography" | "sizing" | "borderWidth" | "spacing" | "opacity" | "dimension" | "borderRadius";
+    /** Retrieve wrapper to certain token (referenced by name) pointing to token value */
+    referenceWrapper(reference: string, options: TokenJSONBuilderOptionsInternal): 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, naming: JSONBuilderNamingOption): string;
+    /** Create full reference name representing token. Such name can, for example, look like: [g1].[g2].[g3].[g4].[token-name] */
+    referenceName(token: Token, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): string;
+    groupIsAbstract(group: TokenGroup): boolean;
+}

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

@@ -0,0 +1,29 @@
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { Token } from "../../../model/tokens/SDKToken";
+import { BorderTokenValue, ColorTokenValue, FontTokenValue, GradientTokenValue, MeasureTokenValue, RadiusTokenValue, ShadowTokenValue, TextTokenValue, 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: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent radius token value either as reference or as plain representation */
+    representRadiusTokenValue(value: RadiusTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent measure token value either as reference or as plain representation */
+    representMeasureTokenValue(value: MeasureTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent font token value either as reference or as plain representation */
+    representFontTokenValue(value: FontTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent text token value either as reference or as plain representation */
+    representTextTokenValue(value: TextTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent typography token value either as reference or as plain representation */
+    representTypographyTokenValue(value: TypographyTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent border token value either as reference or as plain representation */
+    representBorderTokenValue(value: BorderTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent shadow token value either as reference or as plain representation */
+    representShadowTokenValue(value: ShadowTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent gradient token value either as reference or as plain representation */
+    representGradientTokenValue(value: GradientTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Retrieve wrapper to certain token (referenced by name) pointing to token value */
+    referenceWrapper(reference: string, options: TokenJSONBuilderOptionsInternal): string;
+    groupIsAbstract(group: TokenGroup): boolean;
+}

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

@@ -0,0 +1,77 @@
+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 { FontToken } from "../../../model/tokens/SDKFontToken";
+import { GradientToken } from "../../../model/tokens/SDKGradientToken";
+import { MeasureToken } from "../../../model/tokens/SDKMeasureToken";
+import { RadiusToken } from "../../../model/tokens/SDKRadiusToken";
+import { ShadowToken } from "../../../model/tokens/SDKShadowToken";
+import { TextToken } from "../../../model/tokens/SDKTextToken";
+import { Token } from "../../../model/tokens/SDKToken";
+import { BorderTokenValue, ColorTokenValue, FontTokenValue, GradientTokenValue, MeasureTokenValue, RadiusTokenValue, ShadowTokenValue, TextTokenValue, 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: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent full color token, including wrapping meta-information such as user description */
+    representColorToken(token: ColorToken, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent full border token, including wrapping meta-information such as user description */
+    representBorderToken(token: BorderToken, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent full font token, including wrapping meta-information such as user description */
+    representFontToken(token: FontToken, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent full gradient token, including wrapping meta-information such as user description */
+    representGradientToken(token: GradientToken, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent full measure token, including wrapping meta-information such as user description */
+    representMeasureToken(token: MeasureToken, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent full radius token, including wrapping meta-information such as user description */
+    representRadiusToken(token: RadiusToken, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent full shadow token, including wrapping meta-information such as user description */
+    representShadowToken(token: ShadowToken, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent full text token, including wrapping meta-information such as user description */
+    representTextToken(token: TextToken, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent full typography token, including wrapping meta-information such as user description */
+    representTypographyToken(token: TypographyToken, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): Object;
+    /** Represent color token value either as reference or as plain representation */
+    representColorTokenValue(value: ColorTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent radius token value either as reference or as plain representation */
+    representRadiusTokenValue(value: RadiusTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent measure token value either as reference or as plain representation */
+    representMeasureTokenValue(value: MeasureTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent font token value either as reference or as plain representation */
+    representFontTokenValue(value: FontTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent text token value either as reference or as plain representation */
+    representTextTokenValue(value: TextTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent typography token value either as reference or as plain representation */
+    representTypographyTokenValue(value: TypographyTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent border token value either as reference or as plain representation */
+    representBorderTokenValue(value: BorderTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent shadow token value either as reference or as plain representation */
+    representShadowTokenValue(value: ShadowTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent gradient token value either as reference or as plain representation */
+    representGradientTokenValue(value: GradientTokenValue, allTokens: Array<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): Object;
+    /** Create full reference name representing token. Such name can, for example, look like: [g1].[g2].[g3].[g4].[token-name] */
+    referenceName(token: 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, naming: JSONBuilderNamingOption): 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): "border" | "color" | "font" | "gradient" | "measure" | "radius" | "shadow" | "text" | "typography";
+    /** Retrieve chain of groups up to a specified group, ordered from parent to children */
+    referenceGroupChain(containingGroup: TokenGroup): Array<TokenGroup>;
+    groupIsAbstract(group: TokenGroup): boolean;
+}

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

@@ -0,0 +1,23 @@
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { DocumentationPageBlockType } from '../../exports';
+import { DocumentationPage } from '../../model/documentation/SDKDocumentationPage';
+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;
+    version: DesignSystemVersion;
+    constructor(type: MarkdownTransformType, version: DesignSystemVersion);
+    /** Converts entire definition of the page, including its metadata like title and description, to markdown */
+    convertPageToMarkdown(page: DocumentationPage): 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: DocumentationPageBlockType): boolean;
+}

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

@@ -0,0 +1,75 @@
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { DocumentationPageBlockAssets } from '../../model/documentation/blocks/SDKDocumentationPageBlockAssets';
+import { DocumentationPageBlockCallout } from '../../model/documentation/blocks/SDKDocumentationPageBlockCallout';
+import { DocumentationPageBlockCode } from '../../model/documentation/blocks/SDKDocumentationPageBlockCode';
+import { DocumentationPageBlockColumn } from '../../model/documentation/blocks/SDKDocumentationPageBlockColumn';
+import { DocumentationPageBlockColumnItem } from '../../model/documentation/blocks/SDKDocumentationPageBlockColumnItem';
+import { DocumentationPageBlockCustom } from '../../model/documentation/blocks/SDKDocumentationPageBlockCustom';
+import { DocumentationPageBlockDivider } from '../../model/documentation/blocks/SDKDocumentationPageBlockDivider';
+import { DocumentationPageBlockEmbedFigma } from '../../model/documentation/blocks/SDKDocumentationPageBlockEmbedFigma';
+import { DocumentationPageBlockEmbedGeneric } from '../../model/documentation/blocks/SDKDocumentationPageBlockEmbedGeneric';
+import { DocumentationPageBlockEmbedLink } from '../../model/documentation/blocks/SDKDocumentationPageBlockEmbedLink';
+import { DocumentationPageBlockEmbedStorybook } from '../../model/documentation/blocks/SDKDocumentationPageBlockEmbedStorybook';
+import { DocumentationPageBlockEmbedYoutube } from '../../model/documentation/blocks/SDKDocumentationPageBlockEmbedYoutube';
+import { DocumentationPageBlockFrames } from '../../model/documentation/blocks/SDKDocumentationPageBlockFrames';
+import { DocumentationPageBlockHeading } from '../../model/documentation/blocks/SDKDocumentationPageBlockHeading';
+import { DocumentationPageBlockImage } from '../../model/documentation/blocks/SDKDocumentationPageBlockImage';
+import { DocumentationPageOrderedList } from '../../model/documentation/blocks/SDKDocumentationPageBlockOrderedList';
+import { DocumentationPageBlockQuote } from '../../model/documentation/blocks/SDKDocumentationPageBlockQuote';
+import { DocumentationPageBlockRenderCode } from '../../model/documentation/blocks/SDKDocumentationPageBlockRenderCode';
+import { DocumentationPageBlockShortcuts } from '../../model/documentation/blocks/SDKDocumentationPageBlockShortcuts';
+import { DocumentationPageBlockTab } from '../../model/documentation/blocks/SDKDocumentationPageBlockTab';
+import { DocumentationPageBlockTabItem } from '../../model/documentation/blocks/SDKDocumentationPageBlockTabItem';
+import { DocumentationPageBlockTable } from '../../model/documentation/blocks/SDKDocumentationPageBlockTable';
+import { DocumentationPageBlockTableCell } from '../../model/documentation/blocks/SDKDocumentationPageBlockTableCell';
+import { DocumentationPageBlockTableRow } from '../../model/documentation/blocks/SDKDocumentationPageBlockTableRow';
+import { DocumentationPageBlockText } from '../../model/documentation/blocks/SDKDocumentationPageBlockText';
+import { DocumentationPageBlockToken } from '../../model/documentation/blocks/SDKDocumentationPageBlockToken';
+import { DocumentationPageBlockTokenGroup } from '../../model/documentation/blocks/SDKDocumentationPageBlockTokenGroup';
+import { DocumentationPageBlockTokenList } from '../../model/documentation/blocks/SDKDocumentationPageBlockTokenList';
+import { DocumentationPageUnorderedList } from '../../model/documentation/blocks/SDKDocumentationPageBlockUnorderedList';
+import { DocumentationPage } from '../../model/documentation/SDKDocumentationPage';
+import { DocumentationPageBlock } from '../../model/documentation/SDKDocumentationPageBlock';
+import { MarkdownTransformType } from './SDKToolsMarkdownTransform';
+/** Markdown block transformer */
+export declare class MarkdownTransformBlock {
+    private transformType;
+    private utilTransformer;
+    private version;
+    newlineSeparator: string;
+    constructor(type: MarkdownTransformType, version: DesignSystemVersion);
+    /** Converts a single block - depending on the type - to a markdown definition of specific type */
+    convertBlockToMarkdown(block: DocumentationPageBlock, pageContext: DocumentationPage): Promise<string | null>;
+    convertHeadingBlock(block: DocumentationPageBlockHeading): string | null;
+    convertCalloutBlock(block: DocumentationPageBlockCallout): string | null;
+    convertQuoteBlock(block: DocumentationPageBlockQuote): string | null;
+    convertDividerBlock(block: DocumentationPageBlockDivider): string | null;
+    convertImageBlock(block: DocumentationPageBlockImage): string | null;
+    convertOrderedListBlock(block: DocumentationPageOrderedList): string | null;
+    convertUnorderedListBlock(block: DocumentationPageUnorderedList): string | null;
+    convertLiveCodeBlock(block: DocumentationPageBlockRenderCode): string | null;
+    convertCodeBlock(block: DocumentationPageBlockCode): string | null;
+    convertTextBlock(block: DocumentationPageBlockText): string | null;
+    convertGenericEmbedBlock(block: DocumentationPageBlockEmbedGeneric): string | null;
+    convertStorybookEmbedBlock(block: DocumentationPageBlockEmbedStorybook): string | null;
+    convertLinkBlock(block: DocumentationPageBlockEmbedLink): string | null;
+    convertYoutubeEmbedBlock(block: DocumentationPageBlockEmbedYoutube): string | null;
+    convertFigmaEmbedBlock(block: DocumentationPageBlockEmbedFigma): string | null;
+    convertTokenBlock(block: DocumentationPageBlockToken): Promise<string | null>;
+    convertTokenListBlock(block: DocumentationPageBlockTokenList): Promise<string | null>;
+    convertTokenGroupBlock(block: DocumentationPageBlockTokenGroup): Promise<string | null>;
+    private flattenedGroupsFromRoot;
+    convertComponentAssetBlock(block: DocumentationPageBlockAssets): Promise<string | null>;
+    convertFigmaFramesBlock(block: DocumentationPageBlockFrames): string | null;
+    convertShortcutsBlock(block: DocumentationPageBlockShortcuts, pageContext: DocumentationPage): Promise<string | null>;
+    private relativePathToPage;
+    convertTableBlock(block: DocumentationPageBlockTable, pageContext: DocumentationPage): Promise<string | null>;
+    convertTableRowBlock(block: DocumentationPageBlockTableRow): string | null;
+    convertTableCellBlock(block: DocumentationPageBlockTableCell, pageContext: DocumentationPage): Promise<string | null>;
+    convertTabsBlock(block: DocumentationPageBlockTab, pageContext: DocumentationPage): Promise<string | null>;
+    convertTabItemBlock(block: DocumentationPageBlockTabItem, pageContext: DocumentationPage): Promise<string | null>;
+    convertColumnBlock(block: DocumentationPageBlockColumn, pageContext: DocumentationPage): Promise<string | null>;
+    convertColumnItemBlock(block: DocumentationPageBlockColumnItem, pageContext: DocumentationPage): Promise<string | null>;
+    convertCustomBlock(block: DocumentationPageBlockCustom): string | null;
+    convertURLBlock(block: DocumentationPageBlockEmbedGeneric, userAction: string, showLink: boolean): string | null;
+}

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

@@ -0,0 +1,26 @@
+import { DocumentationRichText } from '../../model/documentation/SDKDocumentationRichText';
+import { MarkdownTransformType } from './SDKToolsMarkdownTransform';
+import { DocumentationPageBlockText } from '../../model/documentation/blocks/SDKDocumentationPageBlockText';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { Token } from '../..';
+/** Markdown block transformer */
+export declare class MarkdownTransformUtil {
+    private transformType;
+    private version;
+    private tokenTransformer;
+    constructor(type: MarkdownTransformType, version: DesignSystemVersion);
+    /** 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: DocumentationPageBlockText): 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: DocumentationRichText): 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 Fuse from "fuse.js";
+import { DocumentationPage } from "../../model/documentation/SDKDocumentationPage";
+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<DocumentationPage>) => 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-transform/SDKToolsTokenTransform.d.ts

@@ -0,0 +1,44 @@
+import { Token } from '../../model/tokens/SDKToken';
+import { ColorToken } from '../../model/tokens/SDKColorToken';
+import { BlurTokenValue, BorderTokenValue, ColorTokenValue, FontTokenValue, GenericTokenValue, GradientTokenValue, MeasureTokenValue, RadiusTokenValue, ShadowTokenValue, TextTokenValue, 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 {
+    constructor();
+    /** 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): string;
+    /** Converts border token value to css definition */
+    borderTokenToCSS(value: BorderTokenValue): string;
+    /** Converts shadow token value to css definition */
+    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 */
+    measureTokenToCSS(value: MeasureTokenValue): string;
+    private unitToCSS;
+    /** Converts border token value to css definition */
+    radiusTokenToCSS(value: RadiusTokenValue): string;
+    /** Converts gradient token value to css definition */
+    gradientTokenToCSS(value: GradientTokenValue): string;
+    /** Converts font token value to css definition */
+    fontTokenToCSS(value: FontTokenValue): string;
+    /** Converts generic token value to css definition */
+    genericTokenToCSS(value: GenericTokenValue): string;
+    /** Converts generic token value to css definition */
+    textTokenToCSS(value: TextTokenValue): 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/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;
+}