@supernova-studio/supernova-sdk-beta 1.6.10

package/build/sdk-typescript/src/model/tokens/SDKTokenValue.d.ts

@@ -0,0 +1,113 @@
+import { BlurType } from '../enums/SDKBlurType';
+import { BorderPosition } from '../enums/SDKBorderPosition';
+import { GradientType } from '../enums/SDKGradientType';
+import { ShadowType } from '../enums/SDKShadowType';
+import { TextCase } from '../enums/SDKTextCase';
+import { TextDecoration } from '../enums/SDKTextDecoration';
+import { TokenType } from '../enums/SDKTokenType';
+import { Unit } from '../enums/SDKUnit';
+import { TokenOrigin } from '../support/SDKTokenOrigin';
+import { BlurToken } from './SDKBlurToken';
+import { BorderToken } from './SDKBorderToken';
+import { ColorToken } from './SDKColorToken';
+import { FontToken } from './SDKFontToken';
+import { GenericToken } from './SDKGenericToken';
+import { GradientToken } from './SDKGradientToken';
+import { MeasureToken } from './SDKMeasureToken';
+import { RadiusToken } from './SDKRadiusToken';
+import { ShadowToken } from './SDKShadowToken';
+import { TextToken } from './SDKTextToken';
+import { TypographyToken } from './SDKTypographyToken';
+export type TokenValue = {
+    id: string;
+    name: string;
+    description: string;
+    tokenType: TokenType;
+    origin: TokenOrigin | null;
+};
+export type ColorTokenValue = {
+    hex: string;
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    referencedToken: ColorToken | null;
+};
+export type TypographyTokenValue = {
+    font: FontTokenValue;
+    fontSize: MeasureTokenValue;
+    textDecoration: TextDecoration;
+    textCase: TextCase;
+    letterSpacing: MeasureTokenValue;
+    lineHeight: MeasureTokenValue | null;
+    paragraphIndent: MeasureTokenValue;
+    paragraphSpacing: MeasureTokenValue;
+    referencedToken: TypographyToken | null;
+};
+export type RadiusTokenValue = {
+    radius: MeasureTokenValue;
+    topLeft: MeasureTokenValue | null;
+    topRight: MeasureTokenValue | null;
+    bottomLeft: MeasureTokenValue | null;
+    bottomRight: MeasureTokenValue | null;
+    referencedToken: RadiusToken | null;
+};
+export type ShadowTokenValue = {
+    color: ColorTokenValue;
+    x: MeasureTokenValue;
+    y: MeasureTokenValue;
+    radius: MeasureTokenValue;
+    spread: MeasureTokenValue;
+    opacity: number;
+    type: ShadowType;
+    referencedToken: ShadowToken | null;
+};
+export type MeasureTokenValue = {
+    unit: Unit;
+    measure: number;
+    referencedToken: MeasureToken | null;
+};
+export type FontTokenValue = {
+    family: string;
+    subfamily: string;
+    referencedToken: FontToken | null;
+};
+export type BorderTokenValue = {
+    color: ColorTokenValue;
+    width: MeasureTokenValue;
+    position: BorderPosition;
+    referencedToken: BorderToken | null;
+};
+export type GradientTokenValue = {
+    to: {
+        x: number;
+        y: number;
+    };
+    from: {
+        x: number;
+        y: number;
+    };
+    type: GradientType;
+    aspectRatio: number;
+    stops: Array<GradientStopValue>;
+    referencedToken: GradientToken | null;
+};
+export type GradientStopValue = {
+    position: number;
+    color: ColorTokenValue;
+};
+export type TextTokenValue = {
+    text: string;
+    referencedToken: TextToken;
+};
+export type GenericTokenValue = {
+    text: string;
+    referencedToken: GenericToken;
+};
+export type BlurTokenValue = {
+    type: BlurType;
+    radius: MeasureTokenValue;
+    referencedToken: BlurToken | null;
+};
+export type AnyTokenValue = ColorTokenValue | TextTokenValue | GenericTokenValue | TypographyTokenValue | RadiusTokenValue | ShadowTokenValue | MeasureTokenValue | FontTokenValue | BorderTokenValue | GradientTokenValue | BlurTokenValue;
+export type AnyToken = ColorToken | TextToken | GenericToken | TypographyToken | RadiusToken | ShadowToken | MeasureToken | FontToken | BorderToken | GradientToken | BlurToken;

package/build/sdk-typescript/src/model/tokens/SDKTypographyToken.d.ts

@@ -0,0 +1,19 @@
+import { Brand, ElementProperty } from '../..';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { DTTokenReferenceResolver } from '../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+import { TokenRemoteModel, TypographyTokenRemoteModel } from './remote/SDKRemoteTokenModel';
+import { TypographyTokenRemoteValue } from './remote/SDKRemoteTokenValue';
+import { Token } from './SDKToken';
+import { TypographyTokenValue } from './SDKTokenValue';
+export declare class TypographyToken extends Token {
+    value: TypographyTokenValue;
+    constructor(version: DesignSystemVersion, baseToken: TokenRemoteModel, value: TypographyTokenValue, alias: TypographyToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(version: DesignSystemVersion, brand: Brand, name: string, description: string, value: object, alias: TypographyToken | null, referenceResolver: DTTokenReferenceResolver, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): TypographyToken;
+    static typographyValueFromDefinition(definition: object, referenceResolver: DTTokenReferenceResolver): TypographyTokenValue;
+    toWriteObject(): TypographyTokenRemoteModel;
+    static valueToWriteObject(value: TypographyTokenValue): {
+        aliasTo: string | undefined;
+        value: TypographyTokenRemoteValue;
+    };
+}

package/build/sdk-typescript/src/model/tokens/remote/SDKRemoteTokenData.d.ts

@@ -0,0 +1,45 @@
+import { BlurTokenRemoteValue, BorderTokenRemoteValue, ColorTokenRemoteValue, FontTokenRemoteValue, GradientTokenRemoteValue, MeasureTokenRemoteValue, RadiusTokenRemoteValue, ShadowTokenRemoteValue, TextTokenRemoteValue, TypographyTokenRemoteValue } from './SDKRemoteTokenValue';
+export type ColorTokenRemoteData = {
+    aliasTo?: string;
+    value?: ColorTokenRemoteValue;
+};
+export type TextTokenRemoteData = {
+    aliasTo?: string;
+    value?: TextTokenRemoteValue;
+};
+export type GenericTokenRemoteData = {
+    aliasTo?: string;
+    value?: TextTokenRemoteValue;
+};
+export type TypographyTokenRemoteData = {
+    aliasTo?: string;
+    value?: TypographyTokenRemoteValue;
+};
+export type RadiusTokenRemoteData = {
+    aliasTo?: string;
+    value?: RadiusTokenRemoteValue;
+};
+export type ShadowTokenRemoteData = {
+    aliasTo?: string;
+    value?: ShadowTokenRemoteValue;
+};
+export type MeasureTokenRemoteData = {
+    aliasTo?: string;
+    value?: MeasureTokenRemoteValue;
+};
+export type FontTokenRemoteData = {
+    aliasTo?: string;
+    value?: FontTokenRemoteValue;
+};
+export type BorderTokenRemoteData = {
+    aliasTo?: string;
+    value?: BorderTokenRemoteValue;
+};
+export type GradientTokenRemoteData = {
+    aliasTo?: string;
+    value?: GradientTokenRemoteValue;
+};
+export type BlurTokenRemoteData = {
+    aliasTo?: string;
+    value?: BlurTokenRemoteValue;
+};

package/build/sdk-typescript/src/model/tokens/remote/SDKRemoteTokenModel.d.ts

@@ -0,0 +1,60 @@
+import { TokenType } from '../../enums/SDKTokenType';
+import { BlurTokenRemoteData, BorderTokenRemoteData, ColorTokenRemoteData, FontTokenRemoteData, GenericTokenRemoteData, GradientTokenRemoteData, MeasureTokenRemoteData, RadiusTokenRemoteData, ShadowTokenRemoteData, TextTokenRemoteData, TypographyTokenRemoteData } from './SDKRemoteTokenData';
+export interface TokenRemoteModel {
+    id: string;
+    brandId: string;
+    designSystemVersionId: string;
+    persistentId: string;
+    type: TokenType;
+    meta: {
+        name: string;
+        description: string;
+    };
+    originStyle?: {
+        id?: string;
+        name?: string;
+        sourceId?: string;
+    };
+    data: {
+        aliasTo?: string;
+    };
+    customPropertyOverrides: Array<{
+        propertyId: string;
+        value: any;
+    }>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export type ColorTokenRemoteModel = TokenRemoteModel & {
+    data: ColorTokenRemoteData;
+};
+export type TextTokenRemoteModel = TokenRemoteModel & {
+    data: TextTokenRemoteData;
+};
+export type GenericTokenRemoteModel = TokenRemoteModel & {
+    data: GenericTokenRemoteData;
+};
+export type TypographyTokenRemoteModel = TokenRemoteModel & {
+    data: TypographyTokenRemoteData;
+};
+export type RadiusTokenRemoteModel = TokenRemoteModel & {
+    data: RadiusTokenRemoteData;
+};
+export type ShadowTokenRemoteModel = TokenRemoteModel & {
+    data: ShadowTokenRemoteData;
+};
+export type MeasureTokenRemoteModel = TokenRemoteModel & {
+    data: MeasureTokenRemoteData;
+};
+export type FontTokenRemoteModel = TokenRemoteModel & {
+    data: FontTokenRemoteData;
+};
+export type BorderTokenRemoteModel = TokenRemoteModel & {
+    data: BorderTokenRemoteData;
+};
+export type GradientTokenRemoteModel = TokenRemoteModel & {
+    data: GradientTokenRemoteData;
+};
+export type BlurTokenRemoteModel = TokenRemoteModel & {
+    data: BlurTokenRemoteData;
+};

package/build/sdk-typescript/src/model/tokens/remote/SDKRemoteTokenValue.d.ts

@@ -0,0 +1,72 @@
+import { BlurType } from "../../enums/SDKBlurType";
+import { BorderPosition } from "../../enums/SDKBorderPosition";
+import { GradientType } from "../../enums/SDKGradientType";
+import { ShadowType } from "../../enums/SDKShadowType";
+import { TextCase } from "../../enums/SDKTextCase";
+import { TextDecoration } from "../../enums/SDKTextDecoration";
+import { Unit } from "../../enums/SDKUnit";
+import { ColorTokenRemoteData, FontTokenRemoteData, MeasureTokenRemoteData } from "./SDKRemoteTokenData";
+export type ColorTokenRemoteValue = string;
+export type TextTokenRemoteValue = string;
+export type TypographyTokenRemoteValue = {
+    font: FontTokenRemoteData;
+    fontSize: MeasureTokenRemoteData;
+    textDecoration: TextDecoration;
+    textCase: TextCase;
+    letterSpacing: MeasureTokenRemoteData;
+    lineHeight: MeasureTokenRemoteData | null;
+    paragraphSpacing: MeasureTokenRemoteData;
+    paragraphIndent: MeasureTokenRemoteData;
+};
+export type RadiusTokenRemoteValue = {
+    radius: MeasureTokenRemoteData;
+    topLeft: MeasureTokenRemoteData | null;
+    topRight: MeasureTokenRemoteData | null;
+    bottomLeft: MeasureTokenRemoteData | null;
+    bottomRight: MeasureTokenRemoteData | null;
+};
+export type ShadowTokenRemoteValue = {
+    isEnabled: boolean;
+    color: ColorTokenRemoteData;
+    x: MeasureTokenRemoteData;
+    y: MeasureTokenRemoteData;
+    radius: MeasureTokenRemoteData;
+    spread: MeasureTokenRemoteData;
+    opacity: number;
+    type: ShadowType;
+};
+export type MeasureTokenRemoteValue = {
+    unit: Unit;
+    measure: number;
+};
+export type FontTokenRemoteValue = {
+    family: string;
+    subfamily: string;
+};
+export type BorderTokenRemoteValue = {
+    isEnabled: boolean;
+    color: ColorTokenRemoteData;
+    width: MeasureTokenRemoteData;
+    position: BorderPosition;
+};
+export type GradientTokenRemoteValue = {
+    to: {
+        x: number;
+        y: number;
+    };
+    from: {
+        x: number;
+        y: number;
+    };
+    type: GradientType;
+    aspectRatio: number;
+    stops: Array<GradientStopRemoteValue>;
+};
+export type GradientStopRemoteValue = {
+    position: number;
+    color: ColorTokenRemoteData;
+};
+export type BlurTokenRemoteValue = {
+    type: BlurType;
+    radius: MeasureTokenRemoteData;
+};

package/build/sdk-typescript/src/model/users/SDKUser.d.ts

@@ -0,0 +1,22 @@
+export interface UserModel {
+    id: string;
+    email: string;
+    createdAt: string;
+    profile: {
+        name: string;
+        nickname: string;
+    };
+}
+export declare class User {
+    /** Unique user identifier */
+    id: string;
+    /** Unique user email */
+    email: string;
+    /** When was the user created */
+    createdAt: Date | null;
+    /** User name */
+    name: string;
+    /** User nickname */
+    nickname: string | null;
+    constructor(model: UserModel);
+}

package/build/sdk-typescript/src/tests/Accessors/Brand.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sdk-typescript/src/tests/Accessors/Components.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sdk-typescript/src/tests/Accessors/DesignSystem.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sdk-typescript/src/tests/Accessors/DesignSystemVersion.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sdk-typescript/src/tests/Accessors/Documentation.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sdk-typescript/src/tests/Accessors/Supernova.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sdk-typescript/src/tests/Accessors/Theme.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sdk-typescript/src/tests/Accessors/Workspace.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sdk-typescript/src/tests/Tooling/PluginFigmaTokens.spec.d.ts

@@ -0,0 +1,17 @@
+import { DTPluginToSupernovaMapPack, DTPluginToSupernovaSettings } from '../../tools/design-tokens/utilities/SDKDTMapLoader';
+export declare class FigmaTokensDataLoader {
+    /** Load token definitions from path */
+    loadTokensFromPath(pathToFile: string): Promise<object>;
+    loadTokensFromDirectory(pathToDirectory: string, settingsPath: string): Promise<object>;
+    private getAllJSONFiles;
+    private getFileNameWithoutExtension;
+    private getSetKey;
+    loadConfigFromPath(pathToFile: string): {
+        mapping: DTPluginToSupernovaMapPack;
+        settings: DTPluginToSupernovaSettings;
+    };
+    private weakValidateMapping;
+    private processFileToMapping;
+    private parseDefinition;
+    private loadObjectFile;
+}

package/build/sdk-typescript/src/tests/Tooling/PluginJSONBuilder.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sdk-typescript/src/tests/Tooling/ToolDocSearch.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sdk-typescript/src/tests/Tooling/ToolMarkdownTransform.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sdk-typescript/src/tests/helpers.d.ts

@@ -0,0 +1,2 @@
+import { Supernova } from '../core/SDKSupernova';
+export declare const testInstance: Supernova;

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

@@ -0,0 +1,48 @@
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { TokenGroup } from '../../model/groups/SDKTokenGroup';
+import { Token } from '../../model/tokens/SDKToken';
+import { DTProcessedTokenNode } from './utilities/SDKDTJSONConverter';
+import { DTTokenMergeDiff } from './utilities/SDKDTTokenMerger';
+import { Brand } from '../../core/SDKBrand';
+import { TokenTheme } from '../../model/themes/SDKTokenTheme';
+import { DTPluginToSupernovaMap, DTPluginToSupernovaMapPack, DTPluginToSupernovaSettings } from './utilities/SDKDTMapLoader';
+export type SupernovaToolsDesignTokensLoadingResult = {
+    processedNodes: Array<DTProcessedTokenNode>;
+    tokens: Array<Token>;
+    groups: Array<TokenGroup>;
+};
+export type SupernovaToolsDesignTokensResult = {
+    map: Pick<DTPluginToSupernovaMap, 'bindToBrand' | 'bindToTheme' | 'pluginSets' | 'pluginTheme' | 'type'>;
+    tokensCreated: Array<string>;
+    tokensUpdated: Array<string>;
+    tokensDeleted: Array<string>;
+};
+/** Design Tokens Plugin Manipulation Tool */
+export declare class SupernovaToolsDesignTokensPlugin {
+    private version;
+    private sortMultiplier;
+    constructor(version: DesignSystemVersion);
+    synchronizeTokensFromData(data: object, mapping: DTPluginToSupernovaMapPack, settings: DTPluginToSupernovaSettings): Promise<boolean>;
+    synchronizeTokensFromDataWithResults(data: object, mapping: DTPluginToSupernovaMapPack, settings: DTPluginToSupernovaSettings): Promise<SupernovaToolsDesignTokensResult[]>;
+    private processTokenNodes;
+    private setTokensOrigin;
+    /** Creates pure tree for validation purposes, ignoring any existing token state in workspaces. This method works offline. */
+    createPureTokenTree(processedNodes: Array<DTProcessedTokenNode>, verbose: boolean): Promise<{
+        tokens: Array<Token>;
+        groups: Array<TokenGroup>;
+    }>;
+    /** Loads remote source connected to this tool, then merges tokens and groups with it, creating union. Can optionally write to the source as well */
+    mergeWithRemoteSource(processedNodes: Array<DTProcessedTokenNode>, brand: Brand, write: boolean, verbose: boolean, preciseCopy: boolean): Promise<{
+        tokens: Array<Token>;
+        groups: Array<TokenGroup>;
+        diff: DTTokenMergeDiff;
+    }>;
+    /** Loads remote source connected to this tool, then creates the diff from the base tree and updates the associated theme. Can optionally write to the source as well */
+    mergeThemeWithRemoteSource(processedNodes: Array<DTProcessedTokenNode>, brand: Brand, theme: TokenTheme, write: boolean, verbose: boolean, preciseCopy?: boolean): Promise<{
+        theme: TokenTheme;
+        tokens: Array<Token>;
+    }>;
+    correctSortOrder(tokens: Array<Token>, tokenGroups: Array<TokenGroup>): void;
+    correctSortOrderFromTypeRoot(root: TokenGroup, tokenMap: Map<string, Token>, groupMap: Map<string, TokenGroup>): void;
+    flattenedIdsFromRoot(root: TokenGroup, tokenMap: Map<string, Token>, groupMap: Map<string, TokenGroup>): Array<string>;
+}

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

@@ -0,0 +1,34 @@
+import { Brand } from '../../../core/SDKBrand';
+import { DesignSystemVersion } from '../../../core/SDKDesignSystemVersion';
+import { Token } from '../../../model/tokens/SDKToken';
+import { DTParsedNode } from './SDKDTJSONLoader';
+import { DTPluginToSupernovaMapPack } from './SDKDTMapLoader';
+import { DTTokenReferenceResolver } from './SDKDTTokenReferenceResolver';
+export type DTProcessedTokenNode = {
+    token: Token;
+    originalType: string;
+    path: Array<string>;
+    key: string;
+};
+/** Utility to DS Tokens plugin JSON to Supernova entities */
+export declare class DTJSONConverter {
+    version: DesignSystemVersion;
+    mapping: DTPluginToSupernovaMapPack;
+    referenceResolver: DTTokenReferenceResolver;
+    constructor(version: DesignSystemVersion, mapping: DTPluginToSupernovaMapPack);
+    convertNodesToTokens(nodes: Array<DTParsedNode>, brand: Brand): Array<DTProcessedTokenNode>;
+    private remapRootNodeKeys;
+    private convertNodesToTokensForSupportedNodeTypes;
+    private convertAtomicNode;
+    private convertColorAtomicNode;
+    private convertMeasureAtomicNode;
+    private convertRadiusAtomicNode;
+    private convertShadowAtomicNode;
+    private convertBorderAtomicNode;
+    private convertTypographyAtomicNode;
+    private convertGenericAtomicNode;
+    private convertReferencedNode;
+    private convertPureReferencedNode;
+    private convertComplexReferenceNode;
+    private convertDTTypeToSupernovaType;
+}

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

@@ -0,0 +1,21 @@
+import { Brand, DesignSystemVersion, TokenGroup, TokenType } from '../../..';
+import { DTProcessedTokenNode } from './SDKDTJSONConverter';
+import { DTPluginToSupernovaMapPack } from './SDKDTMapLoader';
+export type DTRootGroupMapping = {
+    snType: TokenType;
+    dtType: string;
+    snRootName: string;
+    dtRootName: string;
+};
+/** Utility for building token trees */
+export declare class DTJSONGroupBuilder {
+    version: DesignSystemVersion;
+    mapping: DTPluginToSupernovaMapPack;
+    constructor(version: DesignSystemVersion, mapping: DTPluginToSupernovaMapPack);
+    /** Create mapping between DT <> SN and assign all tokens into their respective newly created groups */
+    constructAllDefinableGroupsTrees(processedNodes: Array<DTProcessedTokenNode>, brand: Brand): Array<TokenGroup>;
+    /** Create group tree needed to contain entire token tree for particular mapping combination */
+    constructGroupTree(processedNodes: Array<DTProcessedTokenNode>, mapping: DTRootGroupMapping, brand: Brand): Array<TokenGroup>;
+    constructGroupChain(version: DesignSystemVersion, brand: Brand, groups: Map<string, TokenGroup>, path: Array<string>): void;
+    createGroup(brandId: string, versionId: string, name: string, type: TokenType, isRoot: boolean): TokenGroup;
+}

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

@@ -0,0 +1,27 @@
+export type DTParsedNode = {
+    rootKey: string;
+    name: string;
+    path: Array<string>;
+    type: string;
+    value: any;
+    description: string | null;
+};
+export type DTParsedTokenSet = {
+    name: string;
+    id: string;
+    contains: Array<DTParsedNode>;
+};
+export type DTParsedTheme = {
+    name: string;
+    id: string;
+    selectedTokenSets: Array<DTParsedThemeSetPriorityPair>;
+};
+export type DTParsedThemeSetPriorityPair = {
+    set: DTParsedTokenSet;
+    priority: DTParsedThemeSetPriority;
+};
+export declare enum DTParsedThemeSetPriority {
+    source = "source",
+    enabled = "enabled",
+    disabled = "disabled"
+}

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

@@ -0,0 +1,40 @@
+export type DTParsedNode = {
+    rootKey: string;
+    name: string;
+    path: Array<string>;
+    type: string;
+    value: any;
+    description: string | null;
+};
+export type DTParsedTokenSet = {
+    name: string;
+    id: string;
+    contains: Array<DTParsedNode>;
+};
+export type DTParsedTheme = {
+    name: string;
+    id: string;
+    selectedTokenSets: Array<DTParsedThemeSetPriorityPair>;
+};
+export type DTParsedThemeSetPriorityPair = {
+    set: DTParsedTokenSet;
+    priority: DTParsedThemeSetPriority;
+};
+export declare enum DTParsedThemeSetPriority {
+    source = "source",
+    enabled = "enabled",
+    disabled = "disabled"
+}
+/** Design Tokens Plugin Manipulation Tool */
+export declare class DTJSONParser {
+    themeBuffer: Array<DTParsedTheme>;
+    constructor();
+    processPluginDataRepresentation(definition: object): Promise<{
+        nodes: Array<DTParsedNode>;
+        themes: Array<DTParsedTheme>;
+        sets: Array<DTParsedTokenSet>;
+    }>;
+    private processThemes;
+    private processSets;
+    private parseNode;
+}

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

@@ -0,0 +1,39 @@
+import { TokenGroup } from '../../..';
+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 | 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;
+            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,10 @@
+import { DesignSystemVersion } from '../../../core/SDKDesignSystemVersion';
+import { DTParsedTheme, DTParsedTokenSet } from './SDKDTJSONLoader';
+import { DTPluginToSupernovaMap } from './SDKDTMapLoader';
+/** Utility to resolve token maps */
+export declare class DTMapResolver {
+    private version;
+    constructor(version: DesignSystemVersion);
+    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,17 @@
+import { DesignSystemVersion } from "../../../core/SDKDesignSystemVersion";
+import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
+import { TokenTheme } from "../../../model/themes/SDKTokenTheme";
+import { Token } from "../../../model/tokens/SDKToken";
+export type DTThemeMergeDiff = {
+    toUpdate: Array<DTProcessedTokenNode>;
+    toCreate: Array<DTProcessedTokenNode>;
+};
+/** Utility allowing merging of two pools of tokens */
+export declare class DTThemeMerger {
+    private version;
+    constructor(version: DesignSystemVersion);
+    makeTheme(upstreamTokens: Array<Token>, upstreamTheme: TokenTheme, processedNodes: Array<DTProcessedTokenNode>, preciseCopy?: boolean): TokenTheme;
+    replaceIdAcrossAllPossibleReferences(override: DTProcessedTokenNode, newId: string, allTokens: Array<DTProcessedTokenNode>): void;
+    buildKey(path: Array<string>, name: string): string;
+    buildPath(token: Token): Array<string>;
+}

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

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