@supernova-studio/supernova-sdk-beta 1.6.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Supernova.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,144 @@
+<img src="https://github.com/Supernova-Studio/sdk-typescript/blob/main/readme-icon.png?raw=true" alt="Supernova SDK" style="max-width:100%; margin-bottom: 20px;" />
+
+# Supernova JS/TS SDK [![License](https://img.shields.io/badge/License-MIT-lightgray)](https://raw.githubusercontent.com/Supernova-Studio/sdk-typescript/main/LICENSE.md) [![SDK Status](https://img.shields.io/badge/SDK%20Status-Beta-blue)]() [![Version 1.7.0](https://img.shields.io/badge/Version-1.7.0-success)]()
+
+The Supernova SDK provides convenient access to the [Supernova.io](https://supernova.io) platform. It allows you to build design system tooling without worrying about building entire necessary infrastructure like syncing data from Figma, Storybook, writing entire documentation systems etc. - instead, you get all of this out of the box, and you can use the data coming from your single source of truth for any other purpose.
+
+## Features
+
+SDK comes with all functionality (all will come with more once it reaches general release) you need to build design system tooling you previously only dreamt of:
+
+- [x] Read API for `Tokens`, `Assets`, `Components`, `Design Components`
+- [x] Read API for Account-level objects like `Workspaces`, `Design Systems`
+- [x] Support for `single-branded` and `multi-branded` `Design Systems`
+- [x] Read API for `Documentation`, including entire structure, content and configuration
+- [x] Block or markdown `Documentation` representation
+- [x] Rendering pipeline to export your assets as svg, png, pdf
+- [x] Write Token API
+- [ ] (coming) Version management
+- [ ] (coming) Exporter management
+- [ ] (coming) Integrations with awesome community tools (Figma Tokens, Style Dictionary, Raycast..)
+
+And of course, features that make all developers happy!
+
+- [x] Fully Typescript-enabled code
+- [x] Heavily performance-optimized code and caching
+- [x] Fully documented objects and attributes
+- [x] Plug & play library design
+- [x] Performant even for large design systems with lot of data
+- [x] Extensive examples showing most of the capabilities
+- [x] Unit tests
+
+## Installing
+
+To install, simply run:
+
+```bash
+npm install @supernovaio/supernova-sdk
+```
+
+Supernova SDK is made to run in both local (like Node.js) and remote environments (like browsers) so you can use it to develop your React sites or any kind of tool you would like to run as client-side app.
+
+## Examples
+
+We have prepared several examples to show you some things that are possible:
+
+- [x] [Supernova + Gatsby Documentation Site Starter](https://github.com/Supernova-Studio/gatsby-documentation-site/)
+- [x] [Supernova Gatsby Source Plugin](https://github.com/Supernova-Studio/gatsby-source-supernova)
+
+We are working on a few more that will be available once SDK launches out of public beta. If you are interested in building something for Supernova as well, don't hesitate to [reach out](https://community.supernova.io) and talk with us!
+
+
+## Obtaining API Key
+
+Before you can use the SDK, you must obtain your personal access key from your [Supernova.io](https://supernova.io) profile. To do this, sign-in to [Supernova Cloud](https://cloud.supernova.io/), click on your profile picture > profile settings > authentication and generate a new key. [See more information](https://developers.supernova.io/getting-started#obtain-your-developer-key) if you need additional help.
+
+
+## Access Rights
+
+Usage of the SDK adheres to the [general access rights](https://learn.supernova.io/workspace/team-management/roles.html) that the account which generated the access key has. For example, if you are a viewer in a specific workspace, then you will not be able to do any change to that workspace through the SDK and error will be thrown instead. For vast majority of use-cases, being editor-level is enough however.
+
+
+## Quick-start
+
+It is time to put this SDK to good use! To start, import the main Supernova SDK object:
+
+```typescript
+import { Supernova } from "@supernovaio/supernova-sdk"
+```
+
+And instantiate it with your API key:
+
+```typescript
+const supernova = new Supernova(key, null, null) // Ignore 2 additional attributes for now
+```
+
+Supernova instance is used for several purposes, but the main one is to select specific design system you want to fetch the data from.
+
+## How are data structured
+
+All your design system data live under the following structure (that will match your specific setup, what versions you have created and so on):
+
+```
+Workspace 1
+   Design System 1
+      Version Draft
+         Brand 1
+         Brand 2
+      Version 1.0
+         Brand 1
+         Brand 2
+```
+
+- `Workspace` is what you are a member of and is object that encapsulates everything, from your team to all design systems that were created under it. You can be a member of an unlimited number of workspaces, but in the majority of cases users are members of just a single one. You can have different roles and access rights under each of the workspaces you belong to.
+- Every `Design System` belongs to one `Workspace` and contains things like design system configuration, integration settings and admin-related tools.
+- Each `Design System` contains at minimum one active `Version` called `Shared Draft` - this version is where you write your data and is the only one which is allowed to be written to as well. 
+- `Version` is data container for all design system information - like `Tokens`, `Assets`, `DesignComponents` and `Documentation`. 
+- `Version` object has all methods you need to access every piece of data you have in Supernova design system.
+- Each `Version` additionally contains `Brands`. As Supernova supports multi-branded design systems, `Brands` further separate data into data packs that only represent data belonging to one specific brand (for example, set of core tokens shared across all brands, but then subset of tokens specific only to that brand).
+- There is always at least one `Brand` in each `Version`, even if multi-branded functionality is disabled.
+- `Brand` object has all methods you need to access every piece of data you have in Supernova design system related to one specific brand.
+
+To access the data, you first need to select which `Workspace`, `Design System` and `Version` (optionally `Brand`) you want to use.
+
+## Using SDK
+
+You can find full list of [what is possible, and how, here](https://github.com/Supernova-Studio/sdk-typescript/tree/main/docs).
+
+
+## Resolution Caching
+
+Supernova SDK works little bit differently than you would probably expect by default. Because of how complex the design system data is (as an example, a token can contain references to other tokens and can also be made of different types of tokens which can then be used in designComponents...) the SDK does all necessary resolution for you beforehand. 
+
+To allow reuse of the data, the resolved results are cached and used in follow-up resolutions (for example, if you would first access your design tokens and then access documentation that uses the tokens, tokens would be reused). In many situations, this is what you want. However, there are some cases where this behavior is not what you want, like longer-running sessions:
+
+
+### Longer-running sessions
+
+If you are building a client-side app, your users might stay there for a long time without refreshing their session (like reloading a browser). This means the data will always come from the time of the first request as you are always using the same Supernova instance. To prevent this, you can disable cache layer completely:
+
+```typescript
+instance.setResolutionCacheEnabled(false)
+```
+
+With cache disabled, every request will download all necessary information for every request. This is not particulary efficient, especially for very-large design systems, but we put this option so you can control this behavior if you want to. Cache is enabled by default.
+
+
+## What's next
+
+As this is still beta, we are working hard on improving it before the first official release. The following are areas we'd like to solve before general release:
+
+- [ ] DesignComponent API
+- [ ] Write API
+- [ ] Metadata API
+- [ ] Automation triggers
+- [ ] More examples
+
+
+## Contributions
+
+If you have additional ideas about how to make this project better, let us know by opening an issue! You can also open pull requests if you've worked on improving something yourself and would like to contribute back to the community. 
+
+We will be reviewing feature-pull-requests on case-by-case basis, but in general, we are super open to your new ideas and we welcome them! And finally, thank you for your support! You are an amazing community.
+
+Supernova Engineering Team

package/build/sdk-typescript/src/browser-bundle.d.ts

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

package/build/sdk-typescript/src/core/SDKBrand.d.ts

@@ -0,0 +1,80 @@
+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 { TokenType } from '../model/enums/SDKTokenType';
+import { AssetGroup } from '../model/groups/SDKAssetGroup';
+import { DesignComponentGroup } from '../model/groups/SDKDesignComponentGroup';
+import { TokenGroup } from '../model/groups/SDKTokenGroup';
+import { Token } from '../model/tokens/SDKToken';
+import { DataCore } from './data/SDKDataCore';
+import { DesignSystemVersion } from './SDKDesignSystemVersion';
+import { Component } from '../model/components/SDKComponent';
+import { BrandWriter } from './SDKBrandWriter';
+import { Supernova } from './SDKSupernova';
+import { TokenTheme } from '../model/themes/SDKTokenTheme';
+export interface BrandRemoteModel {
+    id: string;
+    designSystemVersionId: string;
+    persistentId: string;
+    meta: {
+        name: string;
+        description: string;
+    };
+}
+export declare class Brand {
+    /** Unique identifier of the brand in this specific version */
+    id: string;
+    /** Unique identifier of the brand */
+    persistentId: string;
+    /** Design System Version in which this brand exists */
+    designSystemVersion: DesignSystemVersion;
+    /** Brand name */
+    name: string;
+    /** Brand description */
+    description: string;
+    /** Internal: Engine */
+    engine: Supernova;
+    /** Internal: Data core */
+    dataCore: DataCore;
+    constructor(engine: Supernova, model: BrandRemoteModel, version: DesignSystemVersion);
+    /** Retrieve write object for this brand */
+    writer(): BrandWriter;
+    /** Fetches all tokens available in this design system version belonging to this specific brand */
+    tokens(forceRefreshCache?: boolean): Promise<Array<Token>>;
+    /** Fetches all tokens and retrieves resolved array of tokens with applied themes */
+    tokensByApplyingThemes(themeIds: Array<string>): Promise<Array<Token>>;
+    /** Fetches all brands available in this design system version belonging to this specific brand */
+    themes(): Promise<Array<TokenTheme>>;
+    /** Fetches all token groups available in this design system version belonging to this specific brand */
+    tokenGroups(): Promise<Array<TokenGroup>>;
+    /** Fetches root of the token group trees. This method returns roots specific to this brand, one group per category */
+    tokenGroupTrees(): Promise<Map<TokenType, TokenGroup>>;
+    /** Fetches all designComponents available in this design system version belonging to this specific brand */
+    components(): Promise<Array<Component>>;
+    /** Fetches all designComponents (Figma for now) available in this design system version belonging to this specific brand */
+    designComponents(): Promise<Array<DesignComponent>>;
+    /** Fetches all designComponent groups as flattened array available in this design system version belonging to this specific brand */
+    designComponentGroups(): Promise<Array<DesignComponentGroup>>;
+    /** Fetches root of the designComponent group tree. This group will contain any other top-level groups that user created and will belong to this specific brand */
+    designComponentGroupTree(): Promise<DesignComponentGroup>;
+    /** Fetches all assets available in this design system version belonging to this specific brand */
+    assets(): Promise<Array<Asset>>;
+    /** Fetches all asset groups as flattened array available in this design system version belonging to this specific brand */
+    assetGroups(): Promise<Array<AssetGroup>>;
+    /** Fetches root of the asset group tree. This group will contain any other top-level groups that user created and will be specific to this brand */
+    assetGroupTree(): Promise<AssetGroup>;
+    /** Renders all assets in this brand and retrieves URLs from which assets can be downloaded as key-value. You can only render one combination of size/format with one request - use more requests if you need to render more.
+     *
+     * Assets that are rendered as "png" will use "scale" attribute, however, when the format is "svg" or "pdf", scale attribute is ignored and will always render the original size.
+     *
+     * Note that assets are not persistent and URLs will expire quickly - you must download them and store them locally / remotely and can never use this URL publicly as it won't work after a short time */
+    renderedAssets(format: AssetFormat, scale: AssetScale): Promise<Array<RenderedAsset>>;
+    /** Renders specific assets in this brand and retrieves URLs from which assets can be downloaded as key-value. You can only render one combination of size/format with one request - use more requests if you need to render more.
+     *
+     * Assets that are rendered as "png" will use "scale" attribute, however, when the format is "svg" or "pdf", scale attribute is ignored and will always render the original size.
+     *
+     * Note that assets are not persistent and URLs will expire quickly - you must download them and store them locally / remotely and can never use this URL publicly as it won't work after a short time */
+    specificRenderedAssets(assets: Array<Asset>, format: AssetFormat, scale: AssetScale): Promise<Array<RenderedAsset>>;
+}

package/build/sdk-typescript/src/core/SDKBrandWriter.d.ts

@@ -0,0 +1,29 @@
+import { TokenGroup } from "../model/groups/SDKTokenGroup";
+import { TokenTheme } from "../model/themes/SDKTokenTheme";
+import { Token } from "../model/tokens/SDKToken";
+import { DataCore } from "./data/SDKDataCore";
+import { Brand } from "./SDKBrand";
+import { Supernova } from "./SDKSupernova";
+export type TokenWriteResponse = {
+    result: "success" | "error";
+    errors: Array<string>;
+    tokens: Array<Token>;
+    tokenGroups: Array<TokenGroup>;
+};
+export type TokenThemeWriteResponse = {
+    result: "success" | "error";
+    errors: Array<string>;
+    theme: TokenTheme;
+};
+export declare class BrandWriter {
+    /** Internal: Associated brand */
+    brand: Brand;
+    /** Internal: Engine */
+    engine: Supernova;
+    /** Internal: Data core */
+    dataCore: DataCore;
+    constructor(engine: Supernova, brand: Brand);
+    /** Fetches all tokens available in this design system version belonging to this specific brand */
+    writeTokens(tokens: Array<Token>, groups: Array<TokenGroup>, deleteTokens: Array<Token>): Promise<TokenWriteResponse>;
+    writeTheme(theme: TokenTheme): Promise<TokenThemeWriteResponse>;
+}

package/build/sdk-typescript/src/core/SDKDesignSystem.d.ts

@@ -0,0 +1,62 @@
+import { Supernova } from "../core/SDKSupernova";
+import { Source, SourceRemoteModel } from "../model/support/SDKSource";
+import { DesignSystemVersion } from "./SDKDesignSystemVersion";
+export interface DesignSystemRemoteModel {
+    id: string;
+    meta: {
+        name: string;
+        description: string;
+    };
+    workspaceId: string;
+    basePrefixes: string[];
+    sources: Array<SourceRemoteModel>;
+    isPublic: boolean;
+    isMultibrand: boolean;
+    docSlug: string;
+    docUserSlug?: string;
+    docExporterId: string;
+    designSystemSwitcher: {
+        isEnabled: boolean;
+        designSystemIds: Array<string>;
+    };
+}
+export declare class DesignSystem {
+    /** Unique identifier of design system */
+    id: string;
+    /** Unique identifier of the workspace in which this design system was created */
+    workspaceId: string;
+    /** Design system name */
+    name: string;
+    /** Design system description */
+    description: string;
+    /** If enabled, parts of the design system can be accessed by public (for example, documentation site) */
+    isPublic: boolean;
+    /** If set, signals that multibrand functionality is enabled for this design system */
+    isMultiBrand: boolean;
+    /** Unique identifier of exporter package used for the documentation */
+    documentationExporterId: string;
+    /** Documentation URL slug */
+    documentationSlug: string;
+    /** Documentation URL slug - user override */
+    documentationUserSlug: string | null;
+    /** Internal: Engine */
+    engine: Supernova;
+    /** Binding multiple design systems together */
+    designSystemSwitcher: {
+        isEnabled: boolean;
+        designSystemIds: Array<string>;
+    };
+    constructor(engine: Supernova, model: DesignSystemRemoteModel);
+    /** Fetches all versions that were created in the design system. Note that there is always at least one version - the "draft" - if there was no version created manually. */
+    versions(): Promise<Array<DesignSystemVersion>>;
+    /** Fetches active design system version - the one to which all changes are being written currently. There is always one active version at any moment. */
+    activeVersion(): Promise<DesignSystemVersion>;
+    /** Get source by source id */
+    sourceById(sourceId: string): Promise<Source | undefined>;
+    /** Fetches all sources that were created in the design system. Used to feed the design system with the data (design & code). */
+    sources(): Promise<Array<Source>>;
+    /** Get Figma file from source id */
+    figmaFileIdForSourceId(sourceId: string): Promise<string | undefined>;
+    /** Get Figma file name from source id */
+    figmaFileNameForSourceId(sourceId: string): Promise<string | undefined>;
+}

package/build/sdk-typescript/src/core/SDKDesignSystemVersion.d.ts

@@ -0,0 +1,99 @@
+import { Supernova } from '../core/SDKSupernova';
+import { AssetFormat, AssetScale, RenderedAsset } from '../exports';
+import { Asset } from '../model/assets/SDKAsset';
+import { Component } from '../model/components/SDKComponent';
+import { DesignComponent } from '../model/components/SDKDesignComponent';
+import { ElementDataView } from '../model/elements/SDKElementDataView';
+import { ElementProperty } from '../model/elements/SDKElementProperty';
+import { TokenType } from '../model/enums/SDKTokenType';
+import { AssetGroup } from '../model/groups/SDKAssetGroup';
+import { DesignComponentGroup } from '../model/groups/SDKDesignComponentGroup';
+import { TokenGroup } from '../model/groups/SDKTokenGroup';
+import { TokenTheme } from '../model/themes/SDKTokenTheme';
+import { Token } from '../model/tokens/SDKToken';
+import { DataCore } from './data/SDKDataCore';
+import { Brand } from './SDKBrand';
+import { DesignSystem } from './SDKDesignSystem';
+import { Documentation } from './SDKDocumentation';
+export interface DesignSystemVersionRemoteModel {
+    id: string;
+    parentId: string;
+    version: string;
+    designSystemId: string;
+    isReadonly: boolean;
+    meta: {
+        name: string;
+        description: string;
+    };
+    createdAt: string;
+    changeLog: string;
+}
+export declare class DesignSystemVersion {
+    /** Unique identifier of design system version */
+    id: string;
+    /** Design system in which this version was created */
+    designSystem: DesignSystem;
+    /** Design system version name */
+    name: string;
+    /** Design system version description */
+    description: string;
+    /** Semantic name of version. Will be null if the version is in draft mode */
+    version: string | null;
+    /** Change log for the version. Will be null if the version is in draft mode */
+    changeLog: string | null;
+    /** If version is in read-only mode, it can't be modified - only documentation that can be improved */
+    isReadOnly: boolean;
+    /** Internal: Engine */
+    engine: Supernova;
+    /** Internal: Data core */
+    dataCore: DataCore;
+    constructor(engine: Supernova, designSystem: DesignSystem, model: DesignSystemVersionRemoteModel);
+    /** Fetches all brands belonging to this design system version. Brand objects can be used to access filtered data belonging to a single brand */
+    brands(): Promise<Array<Brand>>;
+    /** Fetches all tokens in this design system version. This method retrieves all groups defined across all brands */
+    tokens(): Promise<Array<Token>>;
+    /** Fetches all themes in this design system version. This method retrieves all groups defined across all brands */
+    themes(): Promise<Array<TokenTheme>>;
+    /** Fetches all tokens and retrieves resolved array of tokens with applied themes */
+    tokensByApplyingThemes(tokenIds: Array<string>, themeIds: Array<string>): Promise<Array<Token>>;
+    /** Fetches all token groups in this design system version. This method retrieves all groups defined across all brands */
+    tokenGroups(): Promise<Array<TokenGroup>>;
+    /** Fetches root of the token group trees. This method returns all roots, one per each brand you have defined, ordered under separate TokenType, one array per category */
+    tokenGroupTrees(): Promise<Map<TokenType, Array<TokenGroup>>>;
+    /** Fetches all assets in this design system version for all defined brands  */
+    components(): Promise<Array<Component>>;
+    /** Fetches all assets in this design system version for all defined brands  */
+    designComponents(): Promise<Array<DesignComponent>>;
+    /** Fetches all designComponent group in this design system version for all defined brands  */
+    designComponentGroups(): Promise<Array<DesignComponentGroup>>;
+    /** Fetches roots of the designComponent group trees. This group will contain any other top-level groups that user created. This method returns all roots, one per each brand you have defined */
+    designComponentGroupTree(): Promise<Array<DesignComponentGroup>>;
+    /** Fetches all assets in this design system version for all defined brands */
+    assets(): Promise<Array<Asset>>;
+    /** Fetches all asset groups and retrieve them as flat array. You can still access all children of groups with children accessor of group object. This method retrieves all groups across all brands */
+    assetGroups(): Promise<Array<AssetGroup>>;
+    /** Fetches root of the asset group trees. This group will contain any other top-level groups that user created. This method returns all roots, one per each brand you have defined */
+    assetGroupTrees(): Promise<Array<AssetGroup>>;
+    /** Fetches root documentation object containing the entire documentation structure. This will never be null as there is always documentation object attached to a specific design system version */
+    documentation(): Promise<Documentation>;
+    /** Renders all assets in this version and retrieves URLs from which assets can be downloaded as key-value. You can only render one combination of size/format with one request - use more requests if you need to render more.
+     *
+     * Assets that are rendered as "png" will use "scale" attribute, however, when the format is "svg" or "pdf", scale attribute is ignored and will always render the original size.
+     *
+     * Note that assets are not persistent and URLs will expire quickly - you must download them and store them locally / remotely and can never use this URL publicly as it won't work after a short time */
+    renderedAssets(format: AssetFormat, scale: AssetScale): Promise<Array<RenderedAsset>>;
+    /** Renders specific assets in this version and retrieves URLs from which assets can be downloaded as key-value. You can only render one combination of size/format with one request - use more requests if you need to render more.
+     *
+     * Assets that are rendered as "png" will use "scale" attribute, however, when the format is "svg" or "pdf", scale attribute is ignored and will always render the original size.
+     *
+     * Note that assets are not persistent and URLs will expire quickly - you must download them and store them locally / remotely and can never use this URL publicly as it won't work after a short time */
+    specificRenderedAssets(assets: Array<Asset>, format: AssetFormat, scale: AssetScale): Promise<Array<RenderedAsset>>;
+    /** Retrieves property definitions for tokens */
+    tokenProperties(): Promise<Array<ElementProperty>>;
+    /** Retrieves property views for tokens */
+    tokenDataViews(): Promise<Array<ElementDataView>>;
+    /** Retrieves property definitions for components */
+    componentProperties(): Promise<Array<ElementProperty>>;
+    /** Retrieves property views for components */
+    componentDataViews(): Promise<Array<ElementDataView>>;
+}

package/build/sdk-typescript/src/core/SDKDocumentation.d.ts

@@ -0,0 +1,55 @@
+import { ExporterConfigurationProperty } from '../model/exporters/custom_properties/SDKExporterConfigurationProperty';
+import { ExporterCustomBlock } from '../model/exporters/custom_blocks/SDKExporterCustomBlock';
+import { ExporterCustomBlockVariant } from '../model/exporters/custom_blocks/SDKExporterCustomBlockVariant';
+import { DocumentationConfiguration, DocumentationConfigurationModel } from '../model/documentation/SDKDocumentationConfiguration';
+import { DocumentationGroup } from '../model/documentation/SDKDocumentationGroup';
+import { DocumentationItem } from '../model/documentation/SDKDocumentationItem';
+import { DocumentationPage } from '../model/documentation/SDKDocumentationPage';
+import { DesignSystemVersion } from './SDKDesignSystemVersion';
+import { DesignSystem } from './SDKDesignSystem';
+import { WorkspaceNPMRegistry } from '../model/support/SDKWorkspaceNPMRegistry';
+import { ElementProperty } from '..';
+import { ElementDataView } from '../model/elements/SDKElementDataView';
+export interface DocumentationModel {
+    settings: DocumentationConfigurationModel;
+}
+/** Main documentation accessor object. All data associated with documentation can be access through here, such as pages, groups, any block, and also any configuration your editors did. */
+export declare class Documentation {
+    /** Associated version */
+    private version;
+    /** Associated design system */
+    private designSystem;
+    /** Documentation settings */
+    settings: DocumentationConfiguration;
+    constructor(version: DesignSystemVersion, designSystem: DesignSystem, model: DocumentationModel, registry: WorkspaceNPMRegistry | null);
+    /** Main group to which all groups and pages belong. The root group never shows up inside the editor but is always present in data model */
+    rootGroup(): Promise<DocumentationGroup>;
+    /** All items, including pages, groups and group of tab type fetched together */
+    items(): Promise<Array<DocumentationItem>>;
+    /** All groups to which other groups and pages can belong. Each group also contains entire children chain pre-fetched and resolved for convenience */
+    groups(): Promise<Array<DocumentationGroup>>;
+    /** All pages created within documentation presented as flat structure. Each page contains all data neccessary to render it pre-fetched and resolved for convenience */
+    pages(): Promise<Array<DocumentationPage>>;
+    /** All custom blocks that were registered with the active exporter configuration */
+    customBlocks(): Promise<Array<ExporterCustomBlock>>;
+    /** All custom configuration properties that are defined within the active exporter package */
+    customConfiguration(): Promise<Array<ExporterConfigurationProperty>>;
+    /** All custom block variants that are defined within the active exporter package */
+    customBlockVariants(): Promise<Array<ExporterCustomBlockVariant>>;
+    /** Retrieves property definitions for components */
+    pageProperties(): Promise<Array<ElementProperty>>;
+    /** Retrieves property views for components */
+    pageDataViews(): Promise<Array<ElementDataView>>;
+    /** Publish documentation. This queues a build on Supernova's server that will be processed by the asynchronous CI/CD pipeline. You can request status of the build with associated `isBeingPublished` method. */
+    publish(): Promise<{
+        status: 'Queued' | 'InProgress' | 'Failure';
+        jobId: string | null;
+        exporterId: string | null;
+    }>;
+    /** Publish documentation. This queues a build on Supernova's server that will be processed by the asynchronous CI/CD pipeline. You can request status of the build with associated `isBeingPublished` method. */
+    isPublishing(): Promise<{
+        status: 'InProgress' | 'Idle';
+        jobId: string | null;
+        exporterId: string | null;
+    }>;
+}

package/build/sdk-typescript/src/core/SDKSupernova.d.ts

@@ -0,0 +1,46 @@
+import { DataBridge, DataBridgeRequestHook, DebugRequestObserver, DebugResponseObserver } from "./data/SDKDataBridge";
+import { DataCore } from "./data/SDKDataCore";
+import { DesignSystem } from "./SDKDesignSystem";
+import { DesignSystemVersion } from "./SDKDesignSystemVersion";
+import { Workspace } from "./SDKWorkspace";
+import { Exporter } from "../model/exporters/SDKExporter";
+import { Source } from "../model/support/SDKSource";
+import { User } from "../model/users/SDKUser";
+/** Main Supernova.io SDK object. Use this to connect to your data instance and retrieve workspace / design system / version from which you can access all neccessary data. */
+export declare class Supernova {
+    private useResolutionCache;
+    private apiKey;
+    private apiUrl;
+    private apiVersion;
+    private requestHook;
+    private debugRequestObserver;
+    private debugResponseObserver;
+    dataBridge: DataBridge;
+    constructor(apiKey: string, url?: string | null, requestHook?: DataBridgeRequestHook | null, requestObserver?: DebugRequestObserver | null, responseObserver?: DebugResponseObserver | null);
+    /** Fetches current user profile based on the API key provided to Supernova instance. */
+    me(): Promise<User>;
+    /** Fetches all workspaces available under provided API key. Each workspace contains specific design systems, which contain versions, which contain all the design system data. */
+    workspaces(): Promise<Array<Workspace>>;
+    /** Fetches one specific workspace by provided id. Throws when workspace is not found or user doesn't have access to it.  */
+    workspace(workspaceId: string): Promise<Workspace | null>;
+    /** Fetches design systems which belong to a provided workspace. */
+    designSystems(workspaceId: string): Promise<Array<DesignSystem>>;
+    /** Fetches design system by provided id. Throws when design system is not found or user doesn't have access to it. */
+    designSystem(designSystemId: string): Promise<DesignSystem | null>;
+    /** Fetches active design system version - the one to which all changes are being written currently. There is always one active version available for any provided design system. */
+    activeDesignSystemVersion(designSystemId: string): Promise<DesignSystemVersion | null>;
+    /** Fetches all design system versions of provided design system */
+    designSystemVersions(designSystemId: string): Promise<Array<DesignSystemVersion>>;
+    /** Fetches design system version by id */
+    designSystemVersion(designSystemId: string, versionId: string): Promise<DesignSystemVersion | null>;
+    /** Fetches design system sources */
+    designSystemSources(designSystemId: string): Promise<Array<Source>>;
+    /** Fetches exporters belonging to workspace by id */
+    exporters(workspaceId: string): Promise<Array<Exporter>>;
+    /** Enables or disables resolution cache. Because of potential amount of data processed extra when this cache is disabled, only do it when you have a good reason (like if you are building a long-running, client-side app). Cache is enabled by default. */
+    setResolutionCacheEnabled(isEnabled: boolean): void;
+    /** Use this to rebuild data core if the settings change. */
+    rebuildBridge(): void;
+    /** Use this to make version-instance specific data core. Each version must have its own data core, as it caches the data and they can't intermix. Supernova instance has its own data core. */
+    newDataCore(): DataCore;
+}

package/build/sdk-typescript/src/core/SDKWorkspace.d.ts

@@ -0,0 +1,26 @@
+import { Exporter } from "../model/exporters/SDKExporter";
+import { Supernova } from "../core/SDKSupernova";
+import { DesignSystem } from "./SDKDesignSystem";
+export interface WorkspaceRemoteModel {
+    id: string;
+    profile: {
+        name: string;
+        handle: string;
+        color: string;
+    };
+}
+export declare class Workspace {
+    /** Unique identifier of the workspace */
+    id: string;
+    /** Unique URL handle of the workspace */
+    handle: string;
+    /** Workspace name */
+    name: string;
+    /** Private: Engine */
+    engine: Supernova;
+    constructor(engine: Supernova, model: WorkspaceRemoteModel);
+    /** Fetches design systems which belong to this workspace. */
+    designSystems(): Promise<Array<DesignSystem>>;
+    /** Fetches exporters which belong to this workspace. */
+    exporters(): Promise<Array<Exporter>>;
+}

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

@@ -0,0 +1,6 @@
+export declare class Configuration {
+    /** Retrieve API URL for default target */
+    static apiUrlForDefaultEnvironment(): string;
+    /** Retrieve API version for the specific environment accesse */
+    static apiVersionForDefaultEnvironment(): string;
+}

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

@@ -0,0 +1,50 @@
+import { DataCore } from './SDKDataCore';
+type DataBridgeRequestHookResult = {
+    skipDefaultAuth?: boolean;
+};
+export type DataBridgeRequestHook = (request: any) => void | DataBridgeRequestHookResult | Promise<void | DataBridgeRequestHookResult>;
+export type DebugResponseObserver = (info: {
+    requestUrl: string;
+    response: any;
+    executionTime: number;
+    error?: Error;
+}) => void;
+export type DebugRequestObserver = (info: {
+    requestUrl: string;
+    requestMethod: string;
+}) => void;
+export interface DataBridgeConfiguration {
+    apiUrl: string;
+    apiVersion: string;
+    accessToken: string;
+    target: string | null;
+    cache: boolean;
+    requestHook: DataBridgeRequestHook | null;
+    debugRequestObserver?: DebugRequestObserver | null;
+    debugResponseObserver?: DebugResponseObserver | null;
+}
+export declare class DataBridge {
+    authToken: string;
+    cache: boolean;
+    dataCore: DataCore;
+    apiUrl: string;
+    apiVersion: string;
+    target: string | null;
+    requestHook: DataBridgeRequestHook | null;
+    debugRequestObserver: DebugRequestObserver | null;
+    debugResponseObserver: DebugResponseObserver | null;
+    constructor(conf: DataBridgeConfiguration);
+    getDSMGenericDataFromEndpoint(endpoint: string): Promise<any>;
+    getDSMDataFromEndpoint(designSystemId: string, designSystemVersionId: string, endpoint: string): Promise<any>;
+    private buildRequestConfig;
+    private getDataForAuthenticatedEndpoint;
+    postDSMDataToEndpoint(designSystemId: string, designSystemVersionId: string, endpoint: string, data: any, put?: boolean): Promise<any>;
+    postDSMDataToGenericEndpoint(endpoint: string, data: any, put?: boolean): Promise<any>;
+    private postDataForAuthenticatedEndpoint;
+    dsGenericRequestURL(): string;
+    dsWorkspaceRequestURL(wsId: string): string;
+    dsDataRequestURL(dsId: string, dsVersionId: string): string;
+    dsMetadataRequestURL(dsId: string): string;
+    dsVersionRequestURL(dsId: string): string;
+}
+export {};