@supernovaio/cli 1.0.3 → 1.0.4

package/node_modules/@supernovaio/supernova-sdk/build/Typescript/src/core/data/SDKDataCore.d.ts

@@ -0,0 +1,146 @@
+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 '../..';
+import { DocumentationEnvironment } from '../../model/enums/SDKDocumentationEnvironment';
+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>>;
+    getKeyValueStorageData(designSystemId: string, keys: Array<string>): Promise<Record<string, string>>;
+    setKeyValueStorageData(designSystemId: string, kvData: Record<string, string | null>): Promise<any>;
+    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;
+    getTokenStudioData(designSystemId: string, designSystemVersion: DesignSystemVersion): Promise<object>;
+    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>;
+    writeTokenStudioJSONData(designSystemId: string, designSystemVersion: DesignSystemVersion, data: object): Promise<object>;
+    documetationJobs(version: DesignSystemVersion, environment: DocumentationEnvironment, limit?: number): Promise<Array<{
+        status: 'InProgress' | 'Success' | 'Failed';
+        id: string | null;
+        exporterId: string | null;
+    }>>;
+    publishDocumentation(version: DesignSystemVersion, environment: DocumentationEnvironment): Promise<{
+        status: 'Queued' | 'InProgress' | 'Failure';
+        jobId: string | null;
+        exporterId: string | null;
+    }>;
+}

package/node_modules/@supernovaio/supernova-sdk/build/Typescript/src/model/elements/SDKElementProperty.d.ts

@@ -0,0 +1,56 @@
+import { ElementPropertyOption, ElementPropertyOptionRemoteModel } from './SDKElementPropertyOption';
+export declare enum ElementPropertyType {
+    text = "Text",
+    number = "Number",
+    boolean = "Boolean",
+    select = "Select",
+    generic = "Generic",
+    link = "Link",
+    url = "URL"
+}
+export declare enum ElementPropertyTargetElementType {
+    token = "Token",
+    component = "Component",
+    documentationPage = "DocumentationPage"
+}
+export declare enum ElementPropertyLinkElementType {
+    documentationPage = "DocumentationPage",
+    figmaComponent = "FigmaComponent"
+}
+export interface ElementPropertyRemoteModel {
+    id: string;
+    persistentId: string;
+    designSystemVersionId: string;
+    meta: {
+        name: string;
+        description: string;
+    };
+    codeName: string;
+    type: ElementPropertyType;
+    targetElementType: ElementPropertyTargetElementType;
+    linkElementType?: ElementPropertyLinkElementType;
+    options?: Array<ElementPropertyOptionRemoteModel>;
+}
+export declare class ElementProperty {
+    /** Unique id of the component property (data column) */
+    id: string;
+    /** Unique persistent id of the component property (data column) */
+    persistentId: string;
+    /** Specific design system version this property is contained in */
+    designSystemVersionId: string;
+    /** Property name */
+    name: string;
+    /** Code property name - guaranteed to be present, unique and code-safe */
+    codeName: string;
+    /** Property description */
+    description: string | null;
+    /** Base type */
+    propertyType: ElementPropertyType;
+    /** Type of design system object this property is contained in - for example, if this property was configured for DS components, this will be of type `component` */
+    targetElementType: ElementPropertyTargetElementType;
+    /** Type of design system object this property can be configured with */
+    linkElementType: ElementPropertyLinkElementType | null;
+    /** Property options, only available for `select` type */
+    options: Array<ElementPropertyOption> | null;
+    constructor(model: ElementPropertyRemoteModel);
+}

package/node_modules/@supernovaio/supernova-sdk/build/Typescript/src/model/themes/SDKTokenTheme.d.ts

@@ -0,0 +1,63 @@
+import { DesignSystemVersion, Token, TokenType } from '../..';
+import { AnyTokenValue } from '../tokens/SDKTokenValue';
+import { TokenThemeOverrideRemoteModel } from './SDKTokenThemeOverride';
+export interface TokenThemeRemoteModel {
+    meta: {
+        name: string;
+        description: string;
+    };
+    id: string;
+    persistentId: string;
+    designSystemVersionId: string;
+    brandId: string;
+    codeName: string;
+    createdAt?: string;
+    updatedAt?: string;
+    overrides: Array<TokenThemeOverrideRemoteModel>;
+}
+export declare class TokenTheme {
+    id: string;
+    versionedId: string;
+    brandId: string;
+    designSystemVersionId: string;
+    name: string;
+    description: string;
+    codeName: string;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    overriddenTokens: Array<Token>;
+    constructor(model: TokenThemeRemoteModel, dsVersion: DesignSystemVersion);
+    addOverride(override: Token): void;
+    addOverrides(overrides: Array<Token>): void;
+    toWriteObject(): TokenThemeRemoteModel;
+    private tokensToOverrides;
+    toWriteOverrideObject(token: Token): TokenThemeOverrideRemoteModel;
+    valueToWriteObject(value: AnyTokenValue, type: TokenType): {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BlurTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BorderTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: string;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").FontTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").GradientTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").MeasureTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").RadiusTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").ShadowTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").TypographyTokenRemoteValue;
+    };
+}

package/node_modules/@supernovaio/supernova-sdk/build/Typescript/src/model/themes/SDKTokenThemeOverride.d.ts

@@ -0,0 +1,49 @@
+import { TokenType, TokenOrigin } from '../..';
+import { BlurTokenRemoteData, BorderTokenRemoteData, ColorTokenRemoteData, FontTokenRemoteData, GenericTokenRemoteData, GradientTokenRemoteData, MeasureTokenRemoteData, RadiusTokenRemoteData, ShadowTokenRemoteData, TextTokenRemoteData, TypographyTokenRemoteData } from '../tokens/remote/SDKRemoteTokenData';
+import { AnyTokenValue } from '../tokens/SDKTokenValue';
+export interface TokenThemeOverrideRemoteModel {
+    data: ColorTokenRemoteData | TextTokenRemoteData | GenericTokenRemoteData | TypographyTokenRemoteData | RadiusTokenRemoteData | ShadowTokenRemoteData | MeasureTokenRemoteData | FontTokenRemoteData | BorderTokenRemoteData | GradientTokenRemoteData | BlurTokenRemoteData;
+    tokenPersistentId: string;
+    type: TokenType;
+    origin: TokenOrigin | null;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export declare class TokenThemeOverride {
+    value: AnyTokenValue;
+    tokenId: string;
+    type: TokenType;
+    origin: TokenOrigin | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    constructor(model: TokenThemeOverrideRemoteModel, value: AnyTokenValue);
+    toWriteObject(): TokenThemeOverrideRemoteModel;
+    valueToWriteObject(value: AnyTokenValue, type: TokenType): {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BlurTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BorderTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: string;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").FontTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").GradientTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").MeasureTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").RadiusTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").ShadowTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").TypographyTokenRemoteValue;
+    };
+}

package/node_modules/@supernovaio/supernova-sdk/build/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 version;
+    private utilTransformer;
+    private customBlockTransformer;
+    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, pages: DocumentationPage[]): Promise<string | null>;
+    convertHeadingBlock(block: DocumentationPageBlockHeading, pageContext: DocumentationPage, pages: DocumentationPage[]): string | null;
+    convertCalloutBlock(block: DocumentationPageBlockCallout, pageContext: DocumentationPage, pages: DocumentationPage[]): string | null;
+    convertQuoteBlock(block: DocumentationPageBlockQuote, pageContext: DocumentationPage, pages: DocumentationPage[]): string | null;
+    convertDividerBlock(block: DocumentationPageBlockDivider): string | null;
+    convertImageBlock(block: DocumentationPageBlockImage): string | null;
+    convertOrderedListBlock(block: DocumentationPageOrderedList, pageContext: DocumentationPage, pages: DocumentationPage[]): string | null;
+    convertUnorderedListBlock(block: DocumentationPageUnorderedList, pageContext: DocumentationPage, pages: DocumentationPage[]): string | null;
+    convertLiveCodeBlock(block: DocumentationPageBlockRenderCode): string | null;
+    convertCodeBlock(block: DocumentationPageBlockCode): string | null;
+    convertTextBlock(block: DocumentationPageBlockText, pageContext: DocumentationPage, pages: DocumentationPage[]): 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, pages: DocumentationPage[]): Promise<string | null>;
+    convertTableBlock(block: DocumentationPageBlockTable, pageContext: DocumentationPage, pages: DocumentationPage[]): Promise<string | null>;
+    convertTableRowBlock(block: DocumentationPageBlockTableRow): string | null;
+    convertTableCellBlock(block: DocumentationPageBlockTableCell, pageContext: DocumentationPage, pages: DocumentationPage[]): Promise<string | null>;
+    convertTabsBlock(block: DocumentationPageBlockTab, pageContext: DocumentationPage, pages: DocumentationPage[]): Promise<string | null>;
+    convertTabItemBlock(block: DocumentationPageBlockTabItem, pageContext: DocumentationPage, pages: DocumentationPage[]): Promise<string | null>;
+    convertColumnBlock(block: DocumentationPageBlockColumn, pageContext: DocumentationPage, pages: DocumentationPage[]): Promise<string | null>;
+    convertColumnItemBlock(block: DocumentationPageBlockColumnItem, pageContext: DocumentationPage, pages: DocumentationPage[]): Promise<string | null>;
+    convertCustomBlock(block: DocumentationPageBlockCustom, pageContext: DocumentationPage, pages: DocumentationPage[]): Promise<string | null>;
+    convertURLBlock(block: DocumentationPageBlockEmbedGeneric, userAction: string, showLink: boolean): string | null;
+}

package/node_modules/@supernovaio/supernova-sdk/build/Typescript/src/tools/markdown-transform/SDKToolsMarkdownTransformCustomBlock.d.ts

@@ -0,0 +1,18 @@
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { DocumentationPageBlockCustom } from '../../model/documentation/blocks/SDKDocumentationPageBlockCustom';
+import { DocumentationPage } from '../../model/documentation/SDKDocumentationPage';
+import { MarkdownTransformUtil } from './SDKToolsMarkdownTransformUtil';
+/** Markdown custom block transformer */
+export declare class MarkdownTransformCustomBlock {
+    private version;
+    private utilTransformer;
+    private newlineSeparator;
+    constructor(version: DesignSystemVersion, utilTransformer: MarkdownTransformUtil);
+    private getFigmaFileUrl;
+    private formatWarning;
+    private formatComponentName;
+    private formatPropertyValue;
+    convertComponentOverviewAll(block: DocumentationPageBlockCustom, pageContext: DocumentationPage, pages: DocumentationPage[]): Promise<string | null>;
+    convertComponentOverview(block: DocumentationPageBlockCustom, pageContext: DocumentationPage, pages: DocumentationPage[]): Promise<string | null>;
+    convertComponentHealth(block: DocumentationPageBlockCustom, pageContext: DocumentationPage, pages: DocumentationPage[]): Promise<string | null>;
+}

package/node_modules/@supernovaio/supernova-sdk/build/Typescript/src/tools/markdown-transform/SDKToolsMarkdownTransformUtil.d.ts

@@ -0,0 +1,34 @@
+import { DocumentationRichText } from '../../model/documentation/SDKDocumentationRichText';
+import { MarkdownTransformType } from './SDKToolsMarkdownTransform';
+import { DocumentationPageBlockText } from '../../model/documentation/blocks/SDKDocumentationPageBlockText';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { Token, DocumentationPage } 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, pageContext: DocumentationPage, pages: DocumentationPage[]): 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, currentPage: DocumentationPage, pages: DocumentationPage[]): string;
+    private replaceAll;
+    escapeMarkdown(text: string): string;
+    /** Convert token to markdown representation */
+    convertTokenToMarkdown(token: Token): string;
+    formatLinkUrl(label: string, url: string): string;
+    getLinkUrl(currentPage: DocumentationPage, pages: DocumentationPage[], externalUrl: string | undefined, internalId: string | undefined): {
+        url: any;
+        documentationPage?: DocumentationPage;
+    };
+    relativePathToPage(destinationPage: DocumentationPage, currentPage: DocumentationPage): string;
+}