@supernova-studio/supernova-sdk-beta 0.7.17

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,135 @@
+<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 2.0.1](https://img.shields.io/badge/Version-2.0.1-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/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.
+
+
+## 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/sdk"
+```
+
+And instantiate it with your API key:
+
+```typescript
+const supernova = new Supernova(key)
+```
+
+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/.eslintrc.d.cts

@@ -0,0 +1,41 @@
+declare const _extends: string[];
+export { _extends as extends };
+export declare const root: boolean;
+export declare const overrides: {
+    files: string[];
+    plugins: string[];
+    rules: {
+        "@typescript-eslint/unbound-method": string;
+        "jest/unbound-method": string;
+    };
+}[];
+export declare namespace parserOptions {
+    const tsconfigRootDir: string;
+    const project: string[];
+}
+export declare const rules: {
+    "@typescript-eslint/no-unsafe-assignment": string;
+    "@typescript-eslint/no-unsafe-member-access": string;
+    "@typescript-eslint/unbound-method": string;
+    "@typescript-eslint/no-unused-vars": string;
+    "no-restricted-syntax": string;
+    "fp/no-mutation": string;
+    "no-param-reassign": (string | {
+        props: boolean;
+    })[];
+    "@typescript-eslint/restrict-template-expressions": string;
+    "no-nested-ternary": string;
+    "no-prototype-builtins": string;
+    "prefer-destructuring": string;
+    "@typescript-eslint/no-unsafe-argument": string;
+    "@typescript-eslint/no-unsafe-return": string;
+    "@typescript-eslint/no-unsafe-call": string;
+    "@typescript-eslint/no-explicit-any": string;
+    "@typescript-eslint/no-var-requires": string;
+    "no-await-in-loop": string;
+    "no-continue": string;
+    "@typescript-eslint/no-useless-constructor": string;
+    "no-console": string;
+    "@typescript-eslint/require-await": string;
+    "max-classes-per-file": string;
+};

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

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

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

@@ -0,0 +1,77 @@
+import { AreaAssets } from "./areas/SDKAreaAssets";
+import { AreaAutomation } from "./areas/SDKAreaAutomation";
+import { AreaBrands } from "./areas/SDKAreaBrands";
+import { AreaBulkOperations } from "./areas/SDKAreaBulkOperations";
+import { AreaComponents } from "./areas/SDKAreaComponents";
+import { AreaDataSources } from "./areas/SDKAreaDataSources";
+import { AreaDesignSystems } from "./areas/SDKAreaDesignSystems";
+import { AreaDocumentation } from "./areas/SDKAreaDocumentation";
+import { AreaIntegrations } from "./areas/SDKAreaIntegrations";
+import { AreaMe } from "./areas/SDKAreaMe";
+import { AreaMultiplayer } from "./areas/SDKAreaMultiplayer";
+import { AreaNetwork } from "./areas/SDKAreaNetwork";
+import { AreaResources } from "./areas/SDKAreaResources";
+import { AreaStorage } from "./areas/SDKAreaStorage";
+import { AreaTokens } from "./areas/SDKAreaTokens";
+import { AreaUsers } from "./areas/SDKAreaUsers";
+import { AreaVersions } from "./areas/SDKAreaVersions";
+import { AreaWorkspaces } from "./areas/SDKAreaWorkspaces";
+import { DataBridgeRequestHook } from "./data/SDKDataBridge";
+/** 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 apiKey;
+    private apiUrl;
+    private apiVersion;
+    private requestHook;
+    private dataCore;
+    /** Get, create, update, manipulate or delete workspaces */
+    workspaces: AreaWorkspaces;
+    /** Get, create, update, manipulate or delete design systems */
+    designSystems: AreaDesignSystems;
+    /** Get, create, update, manipulate or delete versions */
+    versions: AreaVersions;
+    /** Get, create, update, manipulate or delete brands */
+    brands: AreaBrands;
+    /** Get, create, update, manipulate or delete tokens */
+    tokens: AreaTokens;
+    /** Get, create, update, manipulate or delete components */
+    components: AreaComponents;
+    /** Get, create, update, manipulate or delete assets */
+    assets: AreaAssets;
+    /** Get, create, update, manipulate or delete resources */
+    resources: AreaResources;
+    /** Get, create, update, manipulate or delete documentation items */
+    documentation: AreaDocumentation;
+    /** Get, create, update, manipulate or delete pipelines and automation jobs */
+    automation: AreaAutomation;
+    /** Get, create, update, manipulate or delete users */
+    users: AreaUsers;
+    /** Get, create, update, manipulate or delete current user */
+    me: AreaMe;
+    /** Get, create, update, manipulate or delete integrations */
+    integrations: AreaIntegrations;
+    /** Get, create, update, manipulate or delete data sources */
+    dataSources: AreaDataSources;
+    /** Get, create, update, manipulate or delete data from Supernova en masse */
+    bulkOperations: AreaBulkOperations;
+    /** Read and write data using Supernova key-value storage */
+    storage: AreaStorage;
+    /** Get access to network in exporter packages */
+    network: AreaNetwork;
+    /** Get access to multiplayer capabilities */
+    multiplayer: AreaMultiplayer;
+    /**
+     * Create new Supernova.io SDK object.
+     * @param apiKey API key to use for authentication
+     * @param options Options for SDK
+     * @param options.url URL of the Supernova.io instance to connect to. Defaults to production environment
+     * @param options.requestHook Hook for observing requests
+     * @param options.bypassEnvFetch When enabled, internal node-fetch lib will be used in environments when fetch is not available. Defaults to false
+     */
+    constructor(apiKey: string, options?: {
+        apiUrl?: string;
+        requestHook?: DataBridgeRequestHook;
+        bypassEnvFetch?: boolean;
+        proxyUrl?: string;
+    });
+}

package/build/sdk-typescript/src/core/areas/SDKAreaAssets.d.ts

@@ -0,0 +1,46 @@
+import { DTOFigmaNode } from "@supernova-studio/client";
+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 { AssetGroup } from "../../model/groups/SDKAssetGroup";
+import { DataCore } from "../data/SDKDataCore";
+import { RemoteVersionIdentifier } from "./SDKRemoteIdentifiers";
+export declare class AreaAssets {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Fetches all remote assets in the version
+     * @param from - Remote version to fetch from
+     * @returns All assets in the specified version
+     */
+    getAssets(from: RemoteVersionIdentifier): Promise<Array<Asset>>;
+    /** Fetches all remote asset groups in the version
+     * @param from - Remote version to fetch from
+     * @returns All asset groups in the specified version
+     */
+    getAssetGroups(from: RemoteVersionIdentifier): Promise<Array<AssetGroup>>;
+    /** 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
+     * @param from - Remote version to fetch from
+     * @param assets - Assets to render
+     * @param groups - All asset groups in the version
+     * @param format - Format to render (png, svg, pdf)
+     * @param scale - Scale to render (1x, 2x, 3x, 4x)
+     * @returns All assets that were provided in the request, rendered in the specified format and scale
+     */
+    getRenderedAssets(from: RemoteVersionIdentifier, assets: Array<Asset>, groups: Array<AssetGroup>, format: AssetFormat, scale: AssetScale): Promise<Array<RenderedAsset>>;
+    /** Renders figma frames based on the source and node id. The result is a URL to the hosted image of the Figma frame that is stable across updates.
+     *
+     * @returns Rendered Figma frames
+     */
+    getRenderedFigmaFrames(from: RemoteVersionIdentifier, framesToRender: Array<{
+        sourceId: string;
+        figmaFileNodeId: string;
+    }>): Promise<Array<DTOFigmaNode>>;
+    /** Passes data through Supernova CORS proxy to prevent issues with accessing foreign data from browser */
+    dataThroughCorsProxy(urlToRelay: string): Promise<ArrayBuffer | undefined>;
+}

package/build/sdk-typescript/src/core/areas/SDKAreaAutomation.d.ts

@@ -0,0 +1,233 @@
+import { CodegenAccount } from "../../model/exporters/CodegenAccount";
+import { CodegenAzureOrganization } from "../../model/exporters/CodegenAzureOrganization";
+import { CodegenAzureProject } from "../../model/exporters/CodegenAzureProject";
+import { CodegenAzureRepository } from "../../model/exporters/CodegenAzureRepository";
+import { CodegenBitbucketBranch } from "../../model/exporters/CodegenBitbucketBranch";
+import { CodegenBitbucketProject } from "../../model/exporters/CodegenBitbucketProject";
+import { CodegenBitbucketRepository } from "../../model/exporters/CodegenBitbucketRepository";
+import { CodegenBitbucketWorkspace } from "../../model/exporters/CodegenBitbucketWorkspace";
+import { CodegenBranch } from "../../model/exporters/CodegenBranch";
+import { CodegenConnection } from "../../model/exporters/CodegenConnection";
+import { CodegenGitlabBranch } from "../../model/exporters/CodegenGitlabBranch";
+import { CodegenGitlabGroup } from "../../model/exporters/CodegenGitlabGroup";
+import { CodegenGitlabRepository } from "../../model/exporters/CodegenGitlabRepository";
+import { CodegenRepository } from "../../model/exporters/CodegenRepository";
+import { Exporter, NewExporterPayload } from "../../model/exporters/SDKExporter";
+import { NewPipelinePayload, Pipeline, PipelineUpdateModel } from "../../model/exporters/SDKPipeline";
+import { ExporterCustomBlockVariant } from "../../model/exporters/custom_blocks/SDKExporterCustomBlockVariant";
+import { ExporterConfigurationProperty } from "../../model/exporters/custom_properties/SDKExporterConfigurationProperty";
+import { ExportBuild } from "../../model/exporters/exporter_builds/SDKExportBuild";
+import { ExportBuildResultLog } from "../../model/exporters/exporter_builds/SDKExportBuildResults";
+import { ImportJob } from "../../model/jobs/SDKImportJob";
+import { DataCore } from "../data/SDKDataCore";
+import { RemoteVersionIdentifier } from "./SDKRemoteIdentifiers";
+export declare class AreaAutomation {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Fetches all pipelines that are available by workspace id and design system id */
+    getPipelines(workspaceId: string, designSystemId?: string): Promise<Array<Pipeline>>;
+    /**
+     * Fetches all github connections for user
+     * @returns Github Connections
+     */
+    getGithubConnections(): Promise<CodegenConnection[]>;
+    /**
+     * Fetches github accounts
+     * @returns Github accounts
+     */
+    getGithubAccounts(githubConnectionId: string): Promise<CodegenAccount[]>;
+    /**
+     * Fetches github repositories
+     * @returns Github repositories
+     */
+    getGithubRepositories(githubConnectionId: string, handle: string): Promise<CodegenRepository[]>;
+    /**
+     * Fetches github
+     * @returns Github branches
+     */
+    getGithubBranches(githubConnectionId: string, handle: string, repoName: string): Promise<CodegenBranch[]>;
+    /**
+     * Fetches all Gitlab connections for user
+     * @returns Gitlab Connections
+     */
+    getGitlabConnections(): Promise<CodegenConnection[]>;
+    /**
+     * Fetches Gitlab groups
+     * @param connectionId
+     * @returns Gitlab groups
+     */
+    getGitlabGroups(connectionId: string): Promise<CodegenGitlabGroup[]>;
+    /**
+     * Fetches Gitlab repositories
+     * @param connectionId
+     * @param groupId
+     * @returns Gitlab repositories
+     */
+    getGitlabRepositories(connectionId: string, groupId: string): Promise<CodegenGitlabRepository[]>;
+    /**
+     * Fetches Gitlab
+     * @param connectionId
+     * @param repoId
+     * @returns Gitlab branches
+     */
+    getGitlabBranches(connectionId: string, repoId: string): Promise<CodegenGitlabBranch[]>;
+    /**
+     * Fetches all Azure connections for user
+     * @returns Azure Connections
+     */
+    getAzureConnections(): Promise<CodegenConnection[]>;
+    /**
+     * Fetches Azure organizations
+     * @param connectionId
+     * @returns Azure organizations
+     */
+    getAzureOrganizations(connectionId: string): Promise<CodegenAzureOrganization[]>;
+    /**
+     * Fetches Azure projects
+     * @param connectionId
+     * @param organizationId
+     * @returns Azure projects
+     */
+    getAzureProjects(connectionId: string, organizationId: string): Promise<CodegenAzureProject[]>;
+    /**
+     * Fetches Azure repositories
+     * @param connectionId
+     * @param organizationId
+     * @param projectId
+     * @returns Azure repositories
+     */
+    getAzureRepositories(connectionId: string, organizationId: string, projectId: string): Promise<CodegenAzureRepository[]>;
+    /**
+     * Fetches Azure branches
+     * @param connectionId
+     * @param organizationId
+     * @param projectId
+     * @param repositoryId
+     * @returns Azure branches
+     */
+    getAzureBranches(connectionId: string, organizationId: string, projectId: string, repositoryId: string): Promise<CodegenGitlabBranch[]>;
+    /**
+     * Fetches all Bitbucket connections for user
+     * @returns Bitbucket Connections
+     */
+    getBitbucketConnections(): Promise<CodegenConnection[]>;
+    /**
+     * Fetches Bitbucket workspaces
+     * @param connectionId
+     * @returns Bitbucket workspaces
+     */
+    getBitbucketWorkspaces(connectionId: string): Promise<CodegenBitbucketWorkspace[]>;
+    /**
+     * Fetches Bitbucket projects
+     * @param connectionId
+     * @param workspaceId
+     * @returns Bitbucket projects
+     */
+    getBitbucketProjects(connectionId: string, workspaceId: string): Promise<CodegenBitbucketProject[]>;
+    /**
+     * Fetches Bitbucket repositories
+     * @param connectionId
+     * @param workspaceId
+     * @param projectId
+     * @returns Bitbucket repositories
+     */
+    getBitbucketRepositories(connectionId: string, workspaceId: string, projectId?: string): Promise<CodegenBitbucketRepository[]>;
+    /**
+     * Fetches Bitbucket branches
+     * @param connectionId
+     * @param workspaceId
+     * @param projectId
+     * @param repositoryId
+     * @returns Bitbucket branches
+     */
+    getBitbucketBranches(connectionId: string, workspaceId: string, projectId: string, repositoryId: string): Promise<CodegenBitbucketBranch[]>;
+    /** Fetches all builds of pipelines
+     * @param workspaceId - Identifier of the workspace where the pipeline is installed
+     * @param versionId - Identifier of the version where the pipeline is installed
+     */
+    getExportBuilds(workspaceId: string, versionId: string): Promise<Array<ExportBuild>>;
+    /** Fetches build logs of a specific build
+     * @param workspaceId - Identifier of the workspace where the pipeline is installed
+     * @param buildId - Identifier of the build to fetch logs for
+     */
+    getExportBuildLogs(workspaceId: string, buildId: string): Promise<Array<ExportBuildResultLog>>;
+    /** Fetches exporters belonging to workspace by id */
+    getExporters(workspaceId: string, filter?: {
+        installedOnly?: boolean;
+    }): Promise<Array<Exporter>>;
+    /** Updates exporter
+     * @param workspaceId - Identifier of the workspace where the exporter is installed
+     * @param exporterId - Identifier of the exporter to update
+     * @param payload - Payload to update exporter with
+     */
+    updateExporter(workspaceId: string, exporterId: string, payload: NewExporterPayload): Promise<Exporter>;
+    /** Updates exporter configuration property value
+     * @param designSystemId
+     * @param exporterId
+     * @param propertyKey
+     * @param propertyValue
+     */
+    updateExporterConfigurationPropertyValue(designSystemId: string, exporterId: string, propertyKey: string, propertyValue: any): Promise<void>;
+    /** Deletes exporter configuration property value
+     * @param designSystemId
+     * @param exporterId
+     * @param propertyKey
+     */
+    deleteExporterConfigurationPropertyValue(designSystemId: string, exporterId: string, propertyKey: string): Promise<void>;
+    /** Deletes exporter
+     * @param workspaceId - Identifier of the workspace where the exporter is installed
+     * @param exporterId - Identifier of the exporter to delete
+     */
+    deleteExporter(workspaceId: string, exporterId: string): Promise<void>;
+    /** Pulls latest version of exporter from remote repository
+     * @param workspaceId - Identifier of the workspace where the exporter is installed
+     * @param exporterId - Identifier of the exporter to pull
+     */
+    pullLatestExporter(workspaceId: string, exporterId: string): Promise<Exporter>;
+    /** Fetches all custom configuration properties that specific exporter provides
+     * @param exporterId - Identifier of the exporter to fetch configuration for
+     * @param from - Remote version to fetch from
+     * @returns All custom blocks
+     */
+    getExporterConfiguration(workspaceId: string, exporterId: string, designSystemId: string): Promise<Array<ExporterConfigurationProperty>>;
+    /** Fetches all custom variants that specific exporter provides
+     * @param workspaceId - Identifier of the workspace where the exporter is installed
+     * @param exporterId - Identifier of the exporter to fetch configuration for
+     * @returns All custom variants
+     */
+    getExporterBlockVariants(workspaceId: string, exporterId: string): Promise<Array<ExporterCustomBlockVariant>>;
+    /** Gets all import jobs that are currently in progress.
+     * @param userId - User id to delete integration for. Can only be invoked on user id that is currently authenticated.
+     * @returns Nothing
+     */
+    getImportJobs(from: RemoteVersionIdentifier): Promise<Array<ImportJob>>;
+    getImportJob(from: RemoteVersionIdentifier, jobId: string): Promise<ImportJob>;
+    scheduleImportJobForFigmaSources(from: RemoteVersionIdentifier, sourceIds: Array<string>, dryRun?: boolean): Promise<ImportJob>;
+    /** Create pipeline
+     * @param workspaceId string
+     * @param pipeline Pipeline
+     * @returns Pipeline
+     */
+    createPipeline(workspaceId: string, pipeline: NewPipelinePayload): Promise<Pipeline>;
+    /** Update pipeline
+     * @param workspaceId string
+     * @param pipeline Pipeline
+     * @returns Pipeline
+     */
+    updatePipeline(workspaceId: string, pipelineUpdateModel: PipelineUpdateModel): Promise<Pipeline>;
+    /**
+     * Run pipeline
+     * @param workspaceId string
+     * @param designSystemVersionId string
+     * @param pipelineId string
+     */
+    runPipeline(workspaceId: string, designSystemVersionId: string, pipelineId: string): Promise<Pipeline>;
+    /** Create exporter
+     * @param workspaceId string
+     * @param payload NewExporterPayload
+     * @returns Exporter
+     */
+    createExporter(workspaceId: string, payload: NewExporterPayload): Promise<Exporter>;
+    deletePipeline(workspaceId: string, pipelineId: string): Promise<void>;
+}

package/build/sdk-typescript/src/core/areas/SDKAreaBrands.d.ts

@@ -0,0 +1,35 @@
+import { Brand, BrandUpdateModel } from "../../model/base/SDKBrand";
+import { DataCore } from "../data/SDKDataCore";
+import { RemoteBrandIdentifier, RemoteVersionIdentifier } from "./SDKRemoteIdentifiers";
+export declare class AreaBrands {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Fetches all remote brands in the version
+     * @param from - Remote version to fetch from
+     * @returns All brands in the specified version
+     */
+    getBrands(from: RemoteVersionIdentifier): Promise<Array<Brand>>;
+    /** Fetches a single brand
+     * @param from - Remote brand to fetch from
+     * @returns Brand in the specified version
+     */
+    getBrand(from: RemoteBrandIdentifier): Promise<Brand>;
+    /** Creates new brand and retrieves the newly created brand object.
+     * @param from - Remote brand to fetch from
+     * @param model - new brand model
+     * @returns Newly created brand object
+     */
+    createBrand(from: RemoteVersionIdentifier, model: BrandUpdateModel): Promise<Brand>;
+    /** Edits brand
+     * @param from - Remote brand to fetch from
+     * @param model - new version model
+     * @returns nothing
+     */
+    editBrand(from: RemoteBrandIdentifier, brand: Brand): Promise<void>;
+    /** Deletes brand
+     * @param from - Remote brand to fetch from
+     * @returns nothing
+     */
+    deleteBrand(from: RemoteBrandIdentifier): Promise<void>;
+}

package/build/sdk-typescript/src/core/areas/SDKAreaBulkOperations.d.ts

@@ -0,0 +1,68 @@
+import { Component } from "../../model/components/SDKComponent";
+import { ElementProperty } from "../../model/elements/SDKElementProperty";
+import { TokenGroup } from "../../model/groups/SDKTokenGroup";
+import { ImportJob } from "../../model/jobs/SDKImportJob";
+import { TokenThemeOverrideTranserObject } from "../../model/themes/SDKTokenThemeOverride";
+import { AnyToken } from "../../model/tokens/SDKTokenValue";
+import { DataCore } from "../data/SDKDataCore";
+import { RemoteVersionIdentifier } from "./SDKRemoteIdentifiers";
+export type TokenUpdateTransactionData = {
+    token: AnyToken;
+    tokenParent: TokenGroup;
+    tokenMode: "create" | "update";
+    propertyValuesToCreateOrUpdate?: Array<{
+        property: ElementProperty;
+        value: string | boolean | number;
+    }>;
+    propertyValuesToDelete?: Array<string>;
+    themeValuesToCreate?: Array<{
+        themeId: string;
+        themeOverrideTransferObject: TokenThemeOverrideTranserObject;
+    }>;
+    themeValuesToUpdate?: Array<{
+        themeId: string;
+        themeOverrideTransferObject: TokenThemeOverrideTranserObject;
+    }>;
+    themeValuesToDelete?: Array<string>;
+};
+export type ComponentUpdateTransactionData = {
+    component: Component;
+    componentMode: "create" | "update";
+    propertyValuesToCreateOrUpdate?: Array<{
+        property: ElementProperty;
+        value: string | boolean | number;
+    }>;
+    propertyValuesToDelete?: Array<string>;
+};
+export declare class AreaBulkOperations {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Import tokens in bulk using new import routine
+     *
+     * @param designSystemId - Remote design system to write to
+     * @param brandId - Remote brand to write to
+     * @param sourceName - Name of the source, such as Figma file name
+     * @param sourceId - Unique ID of the source, such as Figma file id
+     * @param sourceType - Source from which import originates. Currently only "FigmaVariablesPlugin" is supported
+     * @param payload - Payload to import. Types to come
+     * @returns Nothing
+     */
+    importTokens(designSystemId: string, brandId: string, sourceId: string, sourceName: string, sourceType: "FigmaVariablesPlugin", payload: any): Promise<ImportJob>;
+    /** Batch updates, creates or deletes token data from Supernova at once. Use this method to perform multiple operations at once instead of chaining single update operations. Batch routine runs everything in a single transaction, so either all operations succeed or all fail.
+     *
+     * WARNING: This method is not yet complete and only supports limited set of operations. Also, doesn't work as transation just yet.
+     * @param to - Remote version to write to
+     * @param data - Update information. All keys except token and its parent are optional and any combination of optional properties is allowed.
+     * @returns Nothing
+     */
+    updateTokenData(to: RemoteVersionIdentifier, data: TokenUpdateTransactionData): Promise<void>;
+    /** Batch updates, creates or deletes component data from Supernova at once. Use this method to perform multiple operations at once instead of chaining single update operations. Batch routine runs everything in a single transaction, so either all operations succeed or all fail.
+     *
+     * WARNING: This method is not yet complete and only supports limited set of operations. Also, doesn't work as transation just yet.
+     * @param to - Remote version to write to
+     * @param data - Update information. All keys except component and its parent are optional and any combination of optional properties is allowed.
+     * @returns Nothing
+     */
+    updateComponentData(to: RemoteVersionIdentifier, data: ComponentUpdateTransactionData): Promise<void>;
+}