@supernova-studio/supernova-sdk-beta 1.6.10

package/build/sdk-typescript/src/core/data/SDKDataCore.d.ts

@@ -0,0 +1,141 @@
+import { Asset } from '../../model/assets/SDKAsset';
+import { RenderedAsset } from '../../model/assets/SDKRenderedAsset';
+import { AssetFormat } from '../../model/enums/SDKAssetFormat';
+import { AssetScale } from '../../model/enums/SDKAssetScale';
+import { DesignComponent } from '../../model/components/SDKDesignComponent';
+import { ExporterCustomBlock } from '../../model/exporters/custom_blocks/SDKExporterCustomBlock';
+import { DocumentationConfiguration } from '../../model/documentation/SDKDocumentationConfiguration';
+import { DocumentationItem } from '../../model/documentation/SDKDocumentationItem';
+import { AssetGroup } from '../../model/groups/SDKAssetGroup';
+import { DesignComponentGroup } from '../../model/groups/SDKDesignComponentGroup';
+import { TokenGroup, TokenGroupRemoteModel } from '../../model/groups/SDKTokenGroup';
+import { TokenRemoteModel } from '../../model/tokens/remote/SDKRemoteTokenModel';
+import { Token } from '../../model/tokens/SDKToken';
+import { DesignSystemVersion } from '../SDKDesignSystemVersion';
+import { Documentation } from '../SDKDocumentation';
+import { DataBridge } from './SDKDataBridge';
+import { ExporterConfigurationProperty } from '../../model/exporters/custom_properties/SDKExporterConfigurationProperty';
+import { DesignSystem } from '../SDKDesignSystem';
+import { ExporterCustomBlockVariant } from '../../model/exporters/custom_blocks/SDKExporterCustomBlockVariant';
+import { Component } from '../../model/components/SDKComponent';
+import { TokenTheme, TokenThemeRemoteModel } from '../../model/themes/SDKTokenTheme';
+import { ElementDataView } from '../../model/elements/SDKElementDataView';
+import { ElementProperty } from '../..';
+export declare class DataCore {
+    private tokensSynced;
+    private tokenGroupsSynced;
+    private themesSynced;
+    private componentsSynced;
+    private designComponentAssetSynced;
+    private designComponentAssetGroupsSynced;
+    private documentationItemsSynced;
+    private documentationSynced;
+    private exporterCustomBlocksSynced;
+    private elementPropertiesSynced;
+    private elementDataViewsSynced;
+    private tokens;
+    private tokenGroups;
+    private themes;
+    private components;
+    private designComponents;
+    private designComponentGroups;
+    private assets;
+    private assetGroups;
+    private documentation;
+    private documentationItems;
+    private exporterCustomBlocks;
+    private elementProperties;
+    private elementDataViews;
+    private bridge;
+    constructor(bridge: DataBridge);
+    /** Get workspace handle from server */
+    private currentWorkspaceHandle;
+    /** Get deisgn system documentation url from server */
+    private currentDeployedDocumentationUrl;
+    currentDesignSystemThemes(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<Array<TokenTheme>>;
+    currentDesignSystemTokens(designSystemId: string, designSystemVersion: DesignSystemVersion, forceRefreshCache?: boolean): Promise<Array<Token>>;
+    currentDesignSystemTokenGroups(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<Array<TokenGroup>>;
+    currentDesignSystemElementProperties(designSystemId: string, designSystemVersion: DesignSystemVersion, forceRefreshCache?: boolean): Promise<Array<ElementProperty>>;
+    currentDesignSystemElementDataViews(designSystemId: string, designSystemVersion: DesignSystemVersion, forceRefreshCache?: boolean): Promise<Array<ElementDataView>>;
+    currentDesignSystemAssets(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<Array<Asset>>;
+    currentDesignSystemAssetGroups(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<Array<AssetGroup>>;
+    renderAssetsForConfiguration(designSystemId: string, designSystemVersion: DesignSystemVersion, assets: Array<Asset>, groups: Array<AssetGroup>, format: AssetFormat, scale: AssetScale): Promise<Array<RenderedAsset>>;
+    assetPath(asset: Asset, parent: AssetGroup): string;
+    currentDesignSystemComponents(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<Array<Component>>;
+    currentDesignSystemDesignComponents(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<Array<DesignComponent>>;
+    currentDesignSystemDesignComponentGroups(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<Array<DesignComponentGroup>>;
+    currentDesignSystemDocumentationItems(designSystem: DesignSystem, designSystemVersion: DesignSystemVersion): Promise<Array<DocumentationItem>>;
+    currentDesignSystemDocumentation(designSystem: DesignSystem, designSystemVersion: DesignSystemVersion): Promise<Documentation>;
+    currentExporterCustomBlocks(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<Array<ExporterCustomBlock>>;
+    currentExporterConfigurationProperties(workspaceId: string, designSystemId: string, exporterId: string, designSystemVersion: DesignSystemVersion): Promise<Array<ExporterConfigurationProperty>>;
+    currentExporterBlockVariants(workspaceId: string, designSystemId: string, exporterId: string, designSystemVersion: DesignSystemVersion): Promise<Array<ExporterCustomBlockVariant>>;
+    /** Update current element views of the documentation */
+    updateElementData(designSystem: string, designSystemVersion: DesignSystemVersion): Promise<void>;
+    private getElementData;
+    /** Prepare design configuration, merging it with pulsar data */
+    updateDocumentationData(designSystem: DesignSystem, designSystemVersion: DesignSystemVersion): Promise<void>;
+    private getDocumentation;
+    private getNPMRegistry;
+    /** Download all custom blocks provided by the currently active exporter */
+    updateExporterCustomBlocksData(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<void>;
+    private getExporterCustomBlocks;
+    private getExporterCustomBlockData;
+    private resolveExporterCustomBlockData;
+    private getExporterConfigurationPropertyUserValues;
+    private getExporterConfigurationPropertiesUserValuesData;
+    private getExporter;
+    private getExporterData;
+    private resolveExporterData;
+    /** Prepare design system data for use for the entire design system, downloading and resolving all tokens */
+    updateTokenData(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<void>;
+    private getTokens;
+    private getRawTokenData;
+    private resolveTokenData;
+    /** Prepare design system data for use for the entire design system, downloading and resolving all groups */
+    updateTokenGroupData(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<void>;
+    private getTokenGroups;
+    private getRawTokenGroupData;
+    private resolveTokenGroupData;
+    /** Prepare design system data for use for the entire design system, downloading and resolving all tokens */
+    updateThemesData(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<void>;
+    private getThemes;
+    private getRawThemeData;
+    private resolveThemeData;
+    /** Prepare design system data for use for the entire design system, downloading and resolving all components - and indirectly, assets as well */
+    updateComponentData(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<void>;
+    private getComponents;
+    private getRawComponentData;
+    private getRawElementPropertyData;
+    private getRawElementPropertyValuesData;
+    private resolveComponentData;
+    /** Prepare design system data for use for the entire design system, downloading and resolving all design components - and indirectly, assets as well */
+    updateDesignComponentAndAssetData(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<void>;
+    private getDesignComponentsAndAssets;
+    private getRawDesignComponentAndAssetData;
+    private resolveDesignComponentAndAssetData;
+    /** Prepare design system data for use for the entire design system, downloading and resolving all groups */
+    updateDesignComponentAndAssetGroupData(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<void>;
+    private getDesignComponentAndAssetGroups;
+    private getRawDesignComponentAndAssetGroupData;
+    private resolveDesignComponentGroupData;
+    private resolveAssetGroupData;
+    updateDocumentationItemData(designSystemId: string, designSystemVersion: DesignSystemVersion, blocks: Array<ExporterCustomBlock>, configuration: DocumentationConfiguration): Promise<void>;
+    private getDocumentationItems;
+    private getRawDocumentationItemData;
+    private resolveDocumentationItemData;
+    writeTokenData(designSystemId: string, designSystemVersion: DesignSystemVersion, tokens: Array<TokenRemoteModel>, groups: Array<TokenGroupRemoteModel>, deleteTokens: Array<Token>): Promise<{
+        tokens: Array<TokenRemoteModel>;
+        tokenGroups: Array<TokenGroup>;
+    }>;
+    writeTokenThemeData(designSystemId: string, designSystemVersion: DesignSystemVersion, theme: TokenThemeRemoteModel): Promise<TokenThemeRemoteModel>;
+    documetationJobs(version: DesignSystemVersion, limit?: number): Promise<Array<{
+        status: 'InProgress' | 'Success' | 'Failed';
+        id: string | null;
+        exporterId: string | null;
+    }>>;
+    publishDocumentation(version: DesignSystemVersion): Promise<{
+        status: 'Queued' | 'InProgress' | 'Failure';
+        jobId: string | null;
+        exporterId: string | null;
+    }>;
+}

package/build/sdk-typescript/src/core/errors/SDKSupernovaError.d.ts

@@ -0,0 +1,24 @@
+/** Supernova SDK-specific error type */
+declare enum SupernovaErrorType {
+    /** Thrown when request was performed but server responded with error */
+    responseError = "response",
+    /** Thrown when request failed to perform, for example when network is unreachable */
+    requestError = "request",
+    /** Thrown when request was performed successfully, but SDK data validation or processing failed */
+    computeError = "compute",
+    /** Thrown when data processing failed */
+    processingError = "processing"
+}
+/** Supernova SDK-specific error. Contains useful information for debugging problems, depending where the problem originated from */
+export declare class SupernovaError extends Error {
+    /** Type of the error thrown */
+    type: SupernovaErrorType;
+    /** Status within 2xx - 5xx range */
+    status: number | null;
+    /** Machine-processable label error unique to each error message thrown by Supernova data server */
+    label: string | null;
+    constructor(message: string, type: SupernovaErrorType);
+    static fromSDKError(message: string): SupernovaError;
+    static fromProcessingError(message: string): SupernovaError;
+}
+export {};

package/build/sdk-typescript/src/core/resolvers/SDKAssetGroupResolver.d.ts

@@ -0,0 +1,14 @@
+import { Asset } from "../../model/assets/SDKAsset";
+import { AssetGroup } from "../../model/groups/SDKAssetGroup";
+import { DesignComponentGroupRemoteModel } from "../../model/groups/SDKDesignComponentGroup";
+export declare class AssetGroupResolver {
+    assets: Array<Asset>;
+    constructor(assets: Array<Asset>);
+    resolveGroupData(data: Array<DesignComponentGroupRemoteModel>): Promise<Array<AssetGroup>>;
+    private recomputePaths;
+    private recomputePathsFromRoot;
+    private reorderGroupsByRoots;
+    private traverseSortGroup;
+    private recomputeParents;
+    private recomputeParentsFromRoot;
+}

package/build/sdk-typescript/src/core/resolvers/SDKComponentResolver.d.ts

@@ -0,0 +1,8 @@
+import { Component, ComponentRemoteModel } from '../../model/components/SDKComponent';
+import { ElementDataViewRemoteModel } from '../../model/elements/SDKElementDataView';
+import { ElementPropertyRemoteModel } from '../../model/elements/SDKElementProperty';
+import { ElementPropertyValueRemoteModel } from '../../model/elements/values/SDKElementPropertyValue';
+export declare class ComponentResolver {
+    constructor();
+    resolveComponentData(components: Array<ComponentRemoteModel>, properties: Array<ElementPropertyRemoteModel>, views: Array<ElementDataViewRemoteModel>, values: Array<ElementPropertyValueRemoteModel>): Promise<Array<Component>>;
+}

package/build/sdk-typescript/src/core/resolvers/SDKDesignComponentGroupResolver.d.ts

@@ -0,0 +1,13 @@
+import { DesignComponent } from "../../model/components/SDKDesignComponent";
+import { DesignComponentGroup, DesignComponentGroupRemoteModel } from "../../model/groups/SDKDesignComponentGroup";
+export declare class DesignComponentGroupResolver {
+    designComponents: Array<DesignComponent>;
+    constructor(designComponents: Array<DesignComponent>);
+    resolveGroupData(data: Array<DesignComponentGroupRemoteModel>): Promise<Array<DesignComponentGroup>>;
+    private recomputePaths;
+    private recomputePathsFromRoot;
+    private reorderGroupsByRoots;
+    private traverseSortGroup;
+    private recomputeParents;
+    private recomputeParentsFromRoot;
+}

package/build/sdk-typescript/src/core/resolvers/SDKDocumentationItemResolver.d.ts

@@ -0,0 +1,32 @@
+import { ExporterCustomBlock } from "../../model/exporters/custom_blocks/SDKExporterCustomBlock";
+import { DocumentationConfiguration } from "../../model/documentation/SDKDocumentationConfiguration";
+import { DocumentationGroupModel } from "../../model/documentation/SDKDocumentationGroup";
+import { DocumentationItemModel, DocumentationItem } from "../../model/documentation/SDKDocumentationItem";
+import { DocumentationPageModel } from "../../model/documentation/SDKDocumentationPage";
+import { DesignSystem } from "../SDKDesignSystem";
+import { DesignSystemVersion } from "../SDKDesignSystemVersion";
+export declare class DocumentationItemResolver {
+    hashedItems: Map<string, DocumentationItemModel>;
+    resolvedItems: Map<string, DocumentationItem>;
+    customBlocks: Array<ExporterCustomBlock>;
+    configuration: DocumentationConfiguration;
+    workspaceHandle: string;
+    designSystem: DesignSystem;
+    version: DesignSystemVersion;
+    docsUrl: string | undefined;
+    constructor(customBlocks: Array<ExporterCustomBlock>, configuration: DocumentationConfiguration, version: DesignSystemVersion, workspaceHandle: string, docsUrl: string | undefined);
+    resolveItemData(pageDetails: Array<DocumentationPageModel>, groupDetails: Array<DocumentationGroupModel>): Promise<Array<DocumentationItem>>;
+    private resolveItemsForGroup;
+    private resolveBlockChains;
+    private resolveBlockGroup;
+    /** Create URL pointing to the deployed documentation page hosted on Supernova side. Will be empty if there was nothing deployed, or if not hosted at Supernova */
+    private deployedUrl;
+    /** Create editor URL pointing to editable page. Since Supernova doesn't link to pages directly yet, this will for now open the editor */
+    private editorUrl;
+    /** Create page URL or group URL pointing to the first contained page */
+    private pageUrl;
+    /** Find first showable page from the top of the provided root */
+    private firstPageFromTop;
+    /** Slugify text to be usable as URL */
+    private slugify;
+}

package/build/sdk-typescript/src/core/resolvers/SDKTokenGroupResolver.d.ts

@@ -0,0 +1,11 @@
+import { TokenGroup, TokenGroupRemoteModel } from "../../model/groups/SDKTokenGroup";
+export declare class TokenGroupResolver {
+    constructor();
+    resolveGroupData(data: Array<TokenGroupRemoteModel>): Promise<Array<TokenGroup>>;
+    private recomputePaths;
+    private recomputePathsFromRoot;
+    private reorderGroupsByRoots;
+    private traverseSortGroup;
+    private recomputeParents;
+    private recomputeParentsFromRoot;
+}

package/build/sdk-typescript/src/core/resolvers/SDKTokenResolver.d.ts

@@ -0,0 +1,76 @@
+import { TokenOrigin } from '../..';
+import { ElementDataViewRemoteModel } from '../../model/elements/SDKElementDataView';
+import { ElementProperty, ElementPropertyRemoteModel } from '../../model/elements/SDKElementProperty';
+import { ElementPropertyValue, ElementPropertyValueRemoteModel } from '../../model/elements/values/SDKElementPropertyValue';
+import { TokenType } from '../../model/enums/SDKTokenType';
+import { TokenGroup } from '../../model/groups/SDKTokenGroup';
+import { TokenTheme, TokenThemeRemoteModel } from '../../model/themes/SDKTokenTheme';
+import { TokenThemeOverrideRemoteModel } from '../../model/themes/SDKTokenThemeOverride';
+import { ColorTokenRemoteData, MeasureTokenRemoteData, FontTokenRemoteData } from '../../model/tokens/remote/SDKRemoteTokenData';
+import { TokenRemoteModel, ColorTokenRemoteModel, BorderTokenRemoteModel, FontTokenRemoteModel, GradientTokenRemoteModel, MeasureTokenRemoteModel, RadiusTokenRemoteModel, ShadowTokenRemoteModel, TextTokenRemoteModel, TypographyTokenRemoteModel, BlurTokenRemoteModel, GenericTokenRemoteModel } from '../../model/tokens/remote/SDKRemoteTokenModel';
+import { BlurTokenRemoteValue, BorderTokenRemoteValue, ColorTokenRemoteValue, FontTokenRemoteValue, GradientStopRemoteValue, GradientTokenRemoteValue, MeasureTokenRemoteValue, RadiusTokenRemoteValue, ShadowTokenRemoteValue, TextTokenRemoteValue, TypographyTokenRemoteValue } from '../../model/tokens/remote/SDKRemoteTokenValue';
+import { BlurToken } from '../../model/tokens/SDKBlurToken';
+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 { BlurTokenValue, BorderTokenValue, ColorTokenValue, FontTokenValue, GenericTokenValue, GradientStopValue, GradientTokenValue, MeasureTokenValue, RadiusTokenValue, ShadowTokenValue, TextTokenValue, TypographyTokenValue } from '../../model/tokens/SDKTokenValue';
+import { TypographyToken } from '../../model/tokens/SDKTypographyToken';
+import { DesignSystemVersion } from '../SDKDesignSystemVersion';
+export declare class TokenResolver {
+    hashedTokens: Map<string, TokenRemoteModel>;
+    resolvedTokens: Map<string, Token>;
+    hashedOverrides: Map<string, TokenThemeOverrideRemoteModel>;
+    hashedReconstructedOverrides: Map<string, Token>;
+    resolvedOverrides: Map<string, Token>;
+    version: DesignSystemVersion;
+    constructor(version: DesignSystemVersion);
+    resolveTokenData(data: Array<TokenRemoteModel>, tokenGroups: Array<TokenGroup>, properties: Array<ElementPropertyRemoteModel>, views: Array<ElementDataViewRemoteModel>, values: Array<ElementPropertyValueRemoteModel>): Array<Token>;
+    tokenTypeIsPure(tokenType: TokenType): boolean;
+    resolveThemeData(data: TokenThemeRemoteModel, tokens: Array<Token>, tokenGroups: Array<TokenGroup>): TokenTheme;
+    makeThemedValuelessTokenReplica(token: Token, themeId: string, origin: TokenOrigin | null): Token;
+    fixMultilayerShadowTokens(tokens: Array<ShadowToken>): void;
+    fixMultilayerGradientTokens(tokens: Array<GradientToken>): void;
+    fixMultilayerBlurTokens(tokens: Array<BlurToken>): void;
+    findAssociatedTokens<T extends Token>(token: T, tokens: Array<T>): Array<T>;
+    actualOriginTokenId(id: string | null): string;
+    constructReferencedToken(rawData: TokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): Token;
+    constructReferencedThemedToken(rawData: TokenThemeOverrideRemoteModel, themeId: string): Token;
+    constructResolvedThemedToken(rawData: TokenThemeOverrideRemoteModel, referencedToken: Token, themeId: string): Token;
+    constructResolvedToken(rawData: TokenRemoteModel, referencedToken: Token, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): Token;
+    constructValueToken(rawData: TokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): Token;
+    constructThemedValueToken(override: TokenThemeOverrideRemoteModel, themeId: string): Token;
+    constructColorToken(rawData: ColorTokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): ColorToken;
+    constructColorValue(rawValue: ColorTokenRemoteValue): ColorTokenValue;
+    constructTextToken(rawData: TextTokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): TextToken;
+    constructGenericToken(rawData: GenericTokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): TextToken;
+    constructTextLikeTokenValue(rawData: TextTokenRemoteValue): TextTokenValue | GenericTokenValue;
+    constructMeasureToken(rawData: MeasureTokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): MeasureToken;
+    constructMeasureValue(rawData: MeasureTokenRemoteValue): MeasureTokenValue;
+    constructFontToken(rawData: FontTokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): FontToken;
+    constructFontValue(rawData: FontTokenRemoteValue): FontTokenValue;
+    constructGradientToken(rawData: GradientTokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): GradientToken;
+    constructGradientTokenValue(rawData: GradientTokenRemoteValue): GradientTokenValue;
+    constructGradientStops(rawData: Array<GradientStopRemoteValue>): Array<GradientStopValue>;
+    constructRadiusToken(rawData: RadiusTokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): RadiusToken;
+    constructRadiusTokenValue(rawData: RadiusTokenRemoteValue): RadiusTokenValue;
+    constructShadowToken(rawData: ShadowTokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): ShadowToken;
+    constructShadowTokenValue(rawData: ShadowTokenRemoteValue): ShadowTokenValue;
+    constructBorderToken(rawData: BorderTokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): BorderToken;
+    constructBorderTokenValue(rawData: BorderTokenRemoteValue): BorderTokenValue;
+    constructTypographyToken(rawData: TypographyTokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): TypographyToken;
+    constructTypographyTokenValue(rawData: TypographyTokenRemoteValue): TypographyTokenValue;
+    constructBlurToken(rawData: BlurTokenRemoteModel, properties: Array<ElementProperty>, values: Array<ElementPropertyValue>): BlurToken;
+    constructBlurTokenValue(rawData: BlurTokenRemoteValue): BlurTokenValue;
+    /** Resolve token color value - meaning we are not creating new tokens, and require raw tokens to be already present */
+    resolveReferencedColorTokenValue(token: ColorTokenRemoteData): ColorTokenValue;
+    /** Resolve token measure value - meaning we are not creating new tokens, and require raw tokens to be already present */
+    resolveReferencedMeasureTokenValue(token: MeasureTokenRemoteData): MeasureTokenValue;
+    /** Resolve token font value - meaning we are not creating new tokens, and require raw tokens to be already present */
+    resolveReferencedFontTokenValue(token: FontTokenRemoteData): FontTokenValue;
+}

package/build/sdk-typescript/src/exports.d.ts

@@ -0,0 +1,117 @@
+export { Supernova } from '../src/core/SDKSupernova';
+export { Brand } from '../src/core/SDKBrand';
+export { DesignSystem } from '../src/core/SDKDesignSystem';
+export { DesignSystemVersion } from '../src/core/SDKDesignSystemVersion';
+export { Workspace } from '../src/core/SDKWorkspace';
+export { User } from '../src/model/users/SDKUser';
+export { Exporter } from '../src/model/exporters/SDKExporter';
+export { ExporterCustomBlock, ExporterCustomBlockMode } from './model/exporters/custom_blocks/SDKExporterCustomBlock';
+export { ExporterCustomBlockProperty, ExporterCustomBlockPropertyType, ExporterCustomBlockPropertyInputType } from './model/exporters/custom_blocks/SDKExporterCustomBlockProperty';
+export { ExporterCustomBlockVariant } from '../src/model/exporters/custom_blocks/SDKExporterCustomBlockVariant';
+export { ExporterConfigurationProperty, ExporterConfigurationPropertyInputType, ExporterConfigurationPropertyType } from '../src/model/exporters/custom_properties/SDKExporterConfigurationProperty';
+export { Asset } from '../src/model/assets/SDKAsset';
+export { RenderedAsset } from '../src/model/assets/SDKRenderedAsset';
+export { Component } from '../src/model/components/SDKComponent';
+export { ElementProperty, ElementPropertyLinkElementType, ElementPropertyTargetElementType, ElementPropertyType } from './model/elements/SDKElementProperty';
+export { ElementPropertyOption } from '../src/model/elements/SDKElementPropertyOption';
+export { ElementDataView } from '../src/model/elements/SDKElementDataView';
+export { ElementDataViewColumn, ElementDataViewColumnBasePropertyType } from '../src/model/elements/SDKElementDataViewColumn';
+export { DesignComponent } from '../src/model/components/SDKDesignComponent';
+export { Documentation } from '../src/core/SDKDocumentation';
+export { DocumentationPageBlockAsset } from '../src/model/documentation/blocks/SDKDocumentationPageBlockAsset';
+export { DocumentationPageBlockAssets } from '../src/model/documentation/blocks/SDKDocumentationPageBlockAssets';
+export { DocumentationPageBlockCallout } from '../src/model/documentation/blocks/SDKDocumentationPageBlockCallout';
+export { DocumentationPageBlockCode } from '../src/model/documentation/blocks/SDKDocumentationPageBlockCode';
+export { DocumentationPageBlockCustom } from '../src/model/documentation/blocks/SDKDocumentationPageBlockCustom';
+export { DocumentationPageBlockDivider } from '../src/model/documentation/blocks/SDKDocumentationPageBlockDivider';
+export { DocumentationPageBlockEmbedFigma } from '../src/model/documentation/blocks/SDKDocumentationPageBlockEmbedFigma';
+export { DocumentationPageBlockEmbedGeneric } from '../src/model/documentation/blocks/SDKDocumentationPageBlockEmbedGeneric';
+export { DocumentationPageBlockEmbedLink } from '../src/model/documentation/blocks/SDKDocumentationPageBlockEmbedLink';
+export { DocumentationPageBlockEmbedStorybook } from '../src/model/documentation/blocks/SDKDocumentationPageBlockEmbedStorybook';
+export { DocumentationPageBlockEmbedYoutube } from '../src/model/documentation/blocks/SDKDocumentationPageBlockEmbedYoutube';
+export { DocumentationPageBlockFrame } from '../src/model/documentation/blocks/SDKDocumentationPageBlockFrame';
+export { DocumentationPageBlockFrames } from '../src/model/documentation/blocks/SDKDocumentationPageBlockFrames';
+export { DocumentationPageBlockHeading } from '../src/model/documentation/blocks/SDKDocumentationPageBlockHeading';
+export { DocumentationPageBlockImage } from '../src/model/documentation/blocks/SDKDocumentationPageBlockImage';
+export { DocumentationPageOrderedList } from '../src/model/documentation/blocks/SDKDocumentationPageBlockOrderedList';
+export { DocumentationPageBlockQuote } from '../src/model/documentation/blocks/SDKDocumentationPageBlockQuote';
+export { DocumentationPageBlockRenderCode } from '../src/model/documentation/blocks/SDKDocumentationPageBlockRenderCode';
+export { DocumentationPageBlockShortcut, DocumentationPageBlockShortcutType } from '../src/model/documentation/blocks/SDKDocumentationPageBlockShortcut';
+export { DocumentationPageBlockShortcuts } from '../src/model/documentation/blocks/SDKDocumentationPageBlockShortcuts';
+export { DocumentationPageBlockText } from '../src/model/documentation/blocks/SDKDocumentationPageBlockText';
+export { DocumentationPageBlockToken } from '../src/model/documentation/blocks/SDKDocumentationPageBlockToken';
+export { DocumentationPageBlockTokenGroup } from '../src/model/documentation/blocks/SDKDocumentationPageBlockTokenGroup';
+export { DocumentationPageBlockTokenList } from '../src/model/documentation/blocks/SDKDocumentationPageBlockTokenList';
+export { DocumentationPageUnorderedList } from '../src/model/documentation/blocks/SDKDocumentationPageBlockUnorderedList';
+export { DocumentationPageBlockColumn } from '../src/model/documentation/blocks/SDKDocumentationPageBlockColumn';
+export { DocumentationPageBlockColumnItem } from '../src/model/documentation/blocks/SDKDocumentationPageBlockColumnItem';
+export { DocumentationPageBlockTab } from '../src/model/documentation/blocks/SDKDocumentationPageBlockTab';
+export { DocumentationPageBlockTabItem } from '../src/model/documentation/blocks/SDKDocumentationPageBlockTabItem';
+export { DocumentationPageBlockTable } from '../src/model/documentation/blocks/SDKDocumentationPageBlockTable';
+export { DocumentationPageBlockTableCell } from '../src/model/documentation/blocks/SDKDocumentationPageBlockTableCell';
+export { DocumentationPageBlockTableRow } from '../src/model/documentation/blocks/SDKDocumentationPageBlockTableRow';
+export { DocumentationPageBlockTableColumn } from '../src/model/documentation/blocks/SDKDocumentationPageBlockTableColumn';
+export { DocumentationItemHeader } from '../src/model/documentation/configuration/SDKDocumentationItemHeader';
+export { DocumentationItemConfiguration } from '../src/model/documentation/configuration/SDKDocumentationItemConfiguration';
+export { DocumentationConfiguration } from '../src/model/documentation/SDKDocumentationConfiguration';
+export { DocumentationGroup } from '../src/model/documentation/SDKDocumentationGroup';
+export { DocumentationItem } from '../src/model/documentation/SDKDocumentationItem';
+export { DocumentationPage } from '../src/model/documentation/SDKDocumentationPage';
+export { DocumentationPageBlock } from '../src/model/documentation/SDKDocumentationPageBlock';
+export { DocumentationPageAsset } from '../src/model/documentation/SDKDocumentationPageAsset';
+export { DocumentationRichText } from '../src/model/documentation/SDKDocumentationRichText';
+export { RichTextSpan } from '../src/model/documentation/SDKDocumentationRichTextSpan';
+export { RichTextSpanAttribute } from '../src/model/documentation/SDKDocumentationRichTextSpanAttribute';
+export { AssetGroup } from '../src/model/groups/SDKAssetGroup';
+export { DesignComponentGroup } from '../src/model/groups/SDKDesignComponentGroup';
+export { TokenGroup } from '../src/model/groups/SDKTokenGroup';
+export { Alignment } from '../src/model/enums/SDKAlignment';
+export { AssetFormat } from '../src/model/enums/SDKAssetFormat';
+export { AssetScale } from '../src/model/enums/SDKAssetScale';
+export { AssetScaleType } from '../src/model/enums/SDKAssetScaleType';
+export { BlurType } from '../src/model/enums/SDKBlurType';
+export { BorderPosition } from '../src/model/enums/SDKBorderPosition';
+export { DocumentationCalloutType } from '../src/model/enums/SDKDocumentationCalloutType';
+export { DocumentationGroupBehavior } from '../src/model/enums/SDKDocumentationGroupBehavior';
+export { DocumentationHeadingType } from '../src/model/enums/SDKDocumentationHeadingType';
+export { DocumentationItemType } from '../src/model/enums/SDKDocumentationItemType';
+export { DocumentationPageAssetType } from '../src/model/enums/SDKDocumentationPageAssetType';
+export { DocumentationPageBlockType } from '../src/model/enums/SDKDocumentationPageBlockType';
+export { DocumentationPageBlockThemeType } from './model/enums/SDKDocumentationPageBlockThemeType';
+export { FrameAlignment } from '../src/model/enums/SDKFrameAlignment';
+export { FrameLayout } from '../src/model/enums/SDKFrameLayout';
+export { GradientType } from '../src/model/enums/SDKGradientType';
+export { RichTextSpanAttributeType } from '../src/model/enums/SDKRichTextSpanAttributeType';
+export { ShadowType } from '../src/model/enums/SDKShadowType';
+export { TextCase } from '../src/model/enums/SDKTextCase';
+export { TextDecoration } from '../src/model/enums/SDKTextDecoration';
+export { TokenType } from '../src/model/enums/SDKTokenType';
+export { Unit } from '../src/model/enums/SDKUnit';
+export { DesignComponentOrigin } from '../src/model/support/SDKDesignComponentOrigin';
+export { Source } from '../src/model/support/SDKSource';
+export { Size } from '../src/model/support/SDKSize';
+export { TokenOrigin } from '../src/model/support/SDKTokenOrigin';
+export { WorkspaceNPMRegistry } from '../src/model/support/SDKWorkspaceNPMRegistry';
+export { BlurToken } from '../src/model/tokens/SDKBlurToken';
+export { BorderToken } from '../src/model/tokens/SDKBorderToken';
+export { ColorToken } from '../src/model/tokens/SDKColorToken';
+export { FontToken } from '../src/model/tokens/SDKFontToken';
+export { GenericToken } from '../src/model/tokens/SDKGenericToken';
+export { GradientToken } from '../src/model/tokens/SDKGradientToken';
+export { MeasureToken } from '../src/model/tokens/SDKMeasureToken';
+export { RadiusToken } from '../src/model/tokens/SDKRadiusToken';
+export { ShadowToken } from '../src/model/tokens/SDKShadowToken';
+export { TypographyToken } from '../src/model/tokens/SDKTypographyToken';
+export { TextToken } from '../src/model/tokens/SDKTextToken';
+export { Token } from '../src/model/tokens/SDKToken';
+export { AnyToken, AnyTokenValue, BlurTokenValue, BorderTokenValue, ColorTokenValue, FontTokenValue, GenericTokenValue, GradientStopValue, GradientTokenValue, MeasureTokenValue, RadiusTokenValue, ShadowTokenValue, TextTokenValue, TokenValue, TypographyTokenValue } from '../src/model/tokens/SDKTokenValue';
+export { TokenTheme } from './model/themes/SDKTokenTheme';
+export { TokenThemeOverride } from './model/themes/SDKTokenThemeOverride';
+export { TokenJSONBuilder, JSONBuilderNamingOption } from './tools/json-builder/SDKToolsJSONBuilder';
+export { DTProcessedTokenNode } from '../src/tools/design-tokens/utilities/SDKDTJSONConverter';
+export { DTTokenMergeDiff } from '../src/tools/design-tokens/utilities/SDKDTTokenMerger';
+export { DTPluginToSupernovaMap, DTPluginToSupernovaMapType, DTPluginToSupernovaMappingFile, DTPluginToSupernovaMapPack, DTPluginToSupernovaSettings } from '../src/tools/design-tokens/utilities/SDKDTMapLoader';
+export { SupernovaToolsDesignTokensPlugin, SupernovaToolsDesignTokensResult } from '../src/tools/design-tokens/SDKToolsDesignTokensPlugin';
+export { DocSearch, DocSearchConfiguration, DocSearchResult, DocSearchResultData, DocSearchResultDataType } from '../src/tools/search-index/SDKToolsDocSearch';
+export { MarkdownTransform, MarkdownTransformType } from '../src/tools/markdown-transform/SDKToolsMarkdownTransform';
+export { TokenTransform } from '../src/tools/token-transform/SDKToolsTokenTransform';

package/build/sdk-typescript/src/index.d.ts

@@ -0,0 +1 @@
+export * from './exports';

package/build/sdk-typescript/src/model/assets/SDKAsset.d.ts

@@ -0,0 +1,16 @@
+import { DesignComponentRemoteModel } from "../components/SDKDesignComponent";
+import { DesignComponentOrigin } from "../support/SDKDesignComponentOrigin";
+import { Source } from "../support/SDKSource";
+export declare class Asset {
+    id: string;
+    brandId: string;
+    thumbnailUrl: string | null;
+    name: string;
+    description: string;
+    componentId: string | null;
+    previouslyDuplicatedNames: number;
+    origin: DesignComponentOrigin | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    constructor(model: DesignComponentRemoteModel, duplicates: number, sources: Array<Source>);
+}

package/build/sdk-typescript/src/model/assets/SDKRenderedAsset.d.ts

@@ -0,0 +1,28 @@
+import { AssetGroup } from "../../model/groups/SDKAssetGroup";
+import { AssetFormat } from "../../model/enums/SDKAssetFormat";
+import { AssetScale } from "../../model/enums/SDKAssetScale";
+import { Asset } from "./SDKAsset";
+export interface RenderedAssetModel {
+    assetId: string;
+    fileName: string;
+    sourceUrl: string;
+    settings: {
+        prefix: string;
+        suffix: string;
+        scale: AssetScale;
+        format: AssetFormat;
+    };
+    originalName: string;
+}
+export declare class RenderedAsset {
+    assetId: string;
+    fileName: string;
+    originalName: string;
+    sourceUrl: string;
+    asset: Asset;
+    group: AssetGroup;
+    scale: AssetScale;
+    format: AssetFormat;
+    previouslyDuplicatedNames: number;
+    constructor(model: RenderedAssetModel, asset: Asset, group: AssetGroup, duplicates: number);
+}

package/build/sdk-typescript/src/model/components/SDKComponent.d.ts

@@ -0,0 +1,27 @@
+import { ElementProperty } from '../elements/SDKElementProperty';
+import { ElementPropertyValue } from './../elements/values/SDKElementPropertyValue';
+export interface ComponentRemoteModel {
+    id: string;
+    persistentId: string;
+    designSystemVersionId: string;
+    brandId: string;
+    meta: {
+        name: string;
+        description: string;
+    };
+    createdAt?: string;
+    updatedAt?: string;
+}
+export declare class Component {
+    id: string;
+    persistentId: string;
+    designSystemVersionId: string;
+    brandId: string;
+    name: string;
+    description: string;
+    properties: Array<ElementProperty>;
+    propertyValues: object;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    constructor(model: ComponentRemoteModel, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+}

package/build/sdk-typescript/src/model/components/SDKDesignComponent.d.ts

@@ -0,0 +1,32 @@
+import { DesignComponentOrigin, DesignComponentOriginModel } from '../support/SDKDesignComponentOrigin';
+import { Source } from '../support/SDKSource';
+export interface DesignComponentRemoteModel {
+    id: string;
+    persistentId: string;
+    designSystemVersionId: string;
+    brandId: string;
+    thumbnailUrl?: string;
+    exportProperties: {
+        isAsset: boolean;
+    };
+    meta: {
+        name: string;
+        description: string;
+    };
+    originComponent?: DesignComponentOriginModel;
+    properties: Array<any>;
+    rootNode?: any;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export declare class DesignComponent {
+    id: string;
+    brandId: string;
+    thumbnailUrl: string | null;
+    name: string;
+    description: string;
+    origin: DesignComponentOrigin | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    constructor(model: DesignComponentRemoteModel, sources: Array<Source>);
+}

package/build/sdk-typescript/src/model/documentation/SDKDocumentationConfiguration.d.ts

@@ -0,0 +1,13 @@
+import { WorkspaceNPMRegistry } from "../support/SDKWorkspaceNPMRegistry";
+export interface DocumentationConfigurationModel {
+    tabbed: boolean;
+    storybookEmbedErrorMessage?: string;
+    renderCodePackageJson?: string;
+}
+export declare class DocumentationConfiguration {
+    tabbedNavigation: boolean;
+    storybookError: string | null;
+    packageJson: string | null;
+    npmRegistry: WorkspaceNPMRegistry | null;
+    constructor(model: DocumentationConfigurationModel, registry: WorkspaceNPMRegistry | null);
+}

package/build/sdk-typescript/src/model/documentation/SDKDocumentationGroup.d.ts

@@ -0,0 +1,38 @@
+import { DocumentationGroupBehavior } from "../enums/SDKDocumentationGroupBehavior";
+import { DocumentationItem, DocumentationItemModel } from "./SDKDocumentationItem";
+import { DocumentationPage } from "./SDKDocumentationPage";
+export interface DocumentationGroupModel extends DocumentationItemModel {
+    isRoot: boolean;
+    childrenIds: Array<string>;
+    groupBehavior: DocumentationGroupBehavior;
+}
+export declare class DocumentationGroup extends DocumentationItem {
+    /** If true, this is unique within documentation (just one) that contains all top-level objects and is root of the docs tree (root > groups > items > blocks ...) */
+    isRoot: boolean;
+    /** IDs of items belonging to the documentation group. Can be page or group */
+    childrenIds: Array<string>;
+    /** Items belonging to the documentation group. Can be page or group */
+    children: Array<DocumentationItem>;
+    /** Parent group reference */
+    parent: DocumentationGroup | null;
+    /** Signifies how the group should behave. If set to "tabs", group behaves as "page", but contains multiple tabbed pages inside it. "Group" signifies virtual group used for content structuring */
+    groupBehavior: DocumentationGroupBehavior;
+    /** Children filtered to be only groups */
+    get subgroups(): Array<DocumentationGroup>;
+    /** Children filtered to be only pages */
+    get pages(): Array<DocumentationPage>;
+    /** Internal */
+    relativeFirstPageUrl: string | null;
+    /** Internal */
+    deployedFirstPageUrl: string | null;
+    constructor(model: DocumentationGroupModel);
+    addChild(item: DocumentationItem): void;
+    addChildren(groups: Array<DocumentationItem>): void;
+    setParent(parent: DocumentationGroup | null): void;
+    /** Internal: Modifies object with new paths. Don't use outside SDK environment as it doesn't propagate the data back to source */
+    internalOverridePaths(relative: string | null, deployed: string | null): void;
+    /** Retrieve relative page path without the associated domain for the first page in the group. Will work even when documentation was not yet deployed */
+    relativeDocsPageUrl(): string | null;
+    /** Retrieve page url for the first page in the group, if the documentation was already deployed (either default or custom domain) */
+    deployedDocsPageUrl(): string | null;
+}