@supernova-studio/supernova-sdk-beta 1.6.10 → 1.6.11

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

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

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

@@ -1,46 +1,52 @@
-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";
+import { AreaAssets } from "./areas/SDKAreaAssets";
+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 { AreaPipelines } from "./areas/SDKAreaPipelines";
+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 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;
+    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 documentation items */
+    documentation: AreaDocumentation;
+    /** Get, create, update, manipulate or delete integrations */
+    integrations: AreaIntegrations;
+    /** 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 pipelines */
+    pipelines: AreaPipelines;
+    /** Get, create, update, manipulate or delete data sources */
+    dataSources: AreaDataSources;
+    /** Get, create, update, manipulate or delete data from Supernova en masse */
+    bulkOperations: AreaBulkOperations;
+    constructor(apiKey: string, url?: string | null, requestHook?: DataBridgeRequestHook | null);
 }

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

@@ -0,0 +1,35 @@
+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>>;
+}

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

@@ -0,0 +1,18 @@
+import { Brand } 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 All brands in the specified version
+     */
+    getBrand(from: RemoteBrandIdentifier): Promise<Brand>;
+}

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

@@ -0,0 +1,31 @@
+import { Brand } from "../../model/base/SDKBrand";
+import { ElementProperty } from "../../model/elements/SDKElementProperty";
+import { TokenGroup } from "../../model/groups/SDKTokenGroup";
+import { TokenTheme } from "../../model/themes/SDKTokenTheme";
+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;
+    }>;
+    propertyValuesToDelete?: Array<string>;
+    themesToUpdate?: Array<TokenTheme>;
+};
+export declare class AreaBulkOperations {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** 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<Array<Brand>>;
+}

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

@@ -0,0 +1,43 @@
+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 { ComponentGroup } from "../../model/groups/SDKComponentGroup";
+import { DesignComponentGroup } from "../../model/groups/SDKDesignComponentGroup";
+import { DataCore } from "../data/SDKDataCore";
+import { RemoteVersionIdentifier } from "./SDKRemoteIdentifiers";
+export declare class AreaComponents {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Fetches all remote components in the version
+     * @param from - Remote version to fetch from
+     * @returns All components in the specified version
+     */
+    getComponents(from: RemoteVersionIdentifier): Promise<Array<Component>>;
+    /** Fetches all remote component groups in the version
+     * @param from - Remote version to fetch from
+     * @returns All component groups in the specified version
+     */
+    getComponentGroups(from: RemoteVersionIdentifier): Promise<Array<ComponentGroup>>;
+    /** Fetches all remote design components in the version
+     * @param from - Remote version to fetch from
+     * @returns All design components in the specified version
+     */
+    getDesignComponents(from: RemoteVersionIdentifier): Promise<Array<DesignComponent>>;
+    /** Fetches all remote design component groups in the version
+     * @param from - Remote version to fetch from
+     * @returns All design component groups in the specified version
+     */
+    getDesignComponentGroups(from: RemoteVersionIdentifier): Promise<Array<DesignComponentGroup>>;
+    /** Retrieves all remote properties for tokens
+     * @param from - Remote version to fetch from
+     * @returns All component properties in the specified version
+     */
+    getComponentProperties(from: RemoteVersionIdentifier): Promise<Array<ElementProperty>>;
+    /** Retrieves all remote property views for components
+     * @param from - Remote version to fetch from
+     * @returns All component views in the specified version
+     */
+    getComponentDataViews(from: RemoteVersionIdentifier): Promise<Array<ElementDataView>>;
+}

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

@@ -0,0 +1,18 @@
+import { Source } from "../../model/support/SDKSource";
+import { DataCore } from "../data/SDKDataCore";
+import { RemoteVersionIdentifier } from "./SDKRemoteIdentifiers";
+export declare class AreaDataSources {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Retrieves a single source by its id
+     * @param from - Remote version to fetch from
+     * @returns Single data source
+     */
+    getDataSourceById(from: RemoteVersionIdentifier, sourceId: string): Promise<Source>;
+    /** Retrieves all sources associated with specified design system
+     * @param from - Remote version to fetch from
+     * @returns All data sources in the specified version
+     */
+    getDataSources(from: RemoteVersionIdentifier): Promise<Array<Source>>;
+}

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

@@ -0,0 +1,17 @@
+import { DesignSystem } from "../../model/base/SDKDesignSystem";
+import { DataCore } from "../data/SDKDataCore";
+export declare class AreaDesignSystems {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Fetches all design systems belonging to the workspace
+     * @param workspaceId - Workspace to fetch from
+     * @returns All design systems in the specified version
+     */
+    designSystems(workspaceId: string): Promise<Array<DesignSystem>>;
+    /** Fetches a specific design system by its id
+     * @param designSystemId - Design system to fetch
+     * @returns Design system with the specified id
+     */
+    designSystem(designSystemId: string): Promise<DesignSystem | null>;
+}

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

@@ -0,0 +1,50 @@
+import { Documentation } from "../../model/base/SDKDocumentation";
+import { DocumentationGroup } from "../../model/documentation/SDKDocumentationGroup";
+import { DocumentationItem } from "../../model/documentation/SDKDocumentationItem";
+import { DocumentationPage } from "../../model/documentation/SDKDocumentationPage";
+import { ElementDataView } from "../../model/elements/SDKElementDataView";
+import { ElementProperty } from "../../model/elements/SDKElementProperty";
+import { ExporterCustomBlock } from "../../model/exporters/custom_blocks/SDKExporterCustomBlock";
+import { DataCore } from "../data/SDKDataCore";
+import { RemoteVersionIdentifier, RemoteWorkspaceVersionIdentifier } from "./SDKRemoteIdentifiers";
+export declare class AreaDocumentation {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Fetches object containing the main information about the docs. This does not contain structure or content of the documentation
+     * @param from - Remote version to fetch from
+     * @returns Documentation object
+     */
+    getDocumentation(from: RemoteWorkspaceVersionIdentifier): Promise<Documentation>;
+    /** Fetches all documentation structural entities, like groups and pages
+     * @param from - Remote version to fetch from
+     * @returns All documentation items
+     */
+    getDocumentationItems(from: RemoteWorkspaceVersionIdentifier): Promise<Array<DocumentationItem>>;
+    /** Fetches all documentation groups
+     * @param from - Remote version to fetch from
+     * @returns All documentation groups
+     */
+    getDocumentationGroups(from: RemoteWorkspaceVersionIdentifier): Promise<Array<DocumentationGroup>>;
+    /** Fetches all documentation pages
+     * @param from - Remote version to fetch from
+     * @returns All documentation pages
+     */
+    getDocumentationPages(from: RemoteWorkspaceVersionIdentifier): Promise<Array<DocumentationPage>>;
+    /** Fetches all custom blocks that are defined in the active documentation exporter
+     * @param from - Remote version to fetch from
+     * @returns All custom blocks
+     */
+    /** All custom blocks that were registered with the active exporter configuration */
+    getCustomBlocks(from: RemoteVersionIdentifier): Promise<Array<ExporterCustomBlock>>;
+    /** Retrieves all remote property definitions for documentation pages
+     * @param from - Remote version to fetch from
+     * @returns All property definitions in the specified version
+     */
+    getPageProperties(from: RemoteVersionIdentifier): Promise<Array<ElementProperty>>;
+    /** Retrieves all remote property views for documentation pages
+     * @param from - Remote version to fetch from
+     * @returns All property views in the specified version
+     */
+    getPageDataViews(from: RemoteVersionIdentifier): Promise<Array<ElementDataView>>;
+}

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

@@ -0,0 +1,26 @@
+import { DataCore } from "../data/SDKDataCore";
+export declare class AreaIntegrations {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Returns URL that can be used to authenticate current user (identified by the token) with Figma
+     * @returns Figma OAuth URL
+     */
+    getFigmaOAuthURL(): Promise<string>;
+    /** Returns URL that can be used to authenticate current user (identified by the token) with GitHub
+     * @returns GitHub OAuth URL
+     */
+    getGitHubOAuthURL(): Promise<string>;
+    /** Returns URL that can be used to authenticate current user (identified by the token) with GitLab
+     * @returns GitLab OAuth URL
+     */
+    getGitLabOAuthURL(): Promise<string>;
+    /** Returns URL that can be used to authenticate current user (identified by the token) with Bitbucket
+     * @returns Bitbucket OAuth URL
+     */
+    getBitbucketOAuthURL(): Promise<string>;
+    /** Returns URL that can be used to authenticate current user (identified by the token) with Azure
+     * @returns Azure OAuth URL
+     */
+    getAzureOAuthURL(): Promise<string>;
+}

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

@@ -0,0 +1,22 @@
+import { User } from "../../model/users/SDKUser";
+import { UserProfileUpdateModel } from "../../model/users/SDKUserProfile";
+import { DataCore } from "../data/SDKDataCore";
+export declare class AreaMe {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Fetches current user profile based on the API key provided to Supernova instance. */
+    me(): Promise<User>;
+    /** Invalidates all session keys for the current user, effectively logging out from all decises. */
+    logout(): Promise<void>;
+    /** Updates the current user based on the API key provided to Supernova instance. */
+    updateProfile(userId: string, profile: UserProfileUpdateModel): Promise<void>;
+    /** Updates the avatar of the current user */
+    updateAvatar(userId: string, avatar: File): Promise<void>;
+    /** Deletes the current user user based on the API key provided to Supernova instance. Also removes all owned workspaces and updates memberships where user belongs. */
+    deleteMe(userId: string): Promise<void>;
+    /** Checks whether user can be deleted. There are certain restrictions, like users who don't have all bills settled in their associated workspaces can't be deleted, for example */
+    canDeleteMe(userId: string): Promise<boolean>;
+    /** Updates the avatar of the current user */
+    deleteAvatar(userId: string): Promise<void>;
+}

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

@@ -0,0 +1,36 @@
+import { ExporterCustomBlockVariant } from "../../model/exporters/custom_blocks/SDKExporterCustomBlockVariant";
+import { ExporterConfigurationProperty } from "../../model/exporters/custom_properties/SDKExporterConfigurationProperty";
+import { Exporter } from "../../model/exporters/SDKExporter";
+import { DataCore } from "../data/SDKDataCore";
+import { RemoteWorkspaceVersionIdentifier } from "./SDKRemoteIdentifiers";
+export declare class AreaPipelines {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Fetches exporters belonging to workspace by id */
+    getExporters(workspaceId: string): Promise<Array<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>>;
+    /** 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(to: RemoteWorkspaceVersionIdentifier): 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(to: RemoteWorkspaceVersionIdentifier): Promise<{
+        status: "InProgress" | "Idle";
+        jobId: string | null;
+        exporterId: string | null;
+    }>;
+}

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

@@ -0,0 +1,140 @@
+import { BlurToken, BlurType, BorderPosition, BorderStyle, BorderToken, GradientToken, GradientType, OpacityToken, RadiusToken, ShadowToken, ShadowType, TextCaseToken, TextDecorationToken, TokenTheme, TypographyToken, VisibilityToken } from "../../exports";
+import { ColorToken } from "../../model/tokens/SDKColorToken";
+import { BorderWidthToken, DimensionToken, DurationToken, FontSizeToken, LetterSpacingToken, LineHeightToken, ParagraphSpacingToken, SizeToken, SpaceToken, ZIndexToken } from "../../model/tokens/SDKDimensionToken";
+import { FontFamilyToken, FontWeightToken, ProductCopyToken, StringToken } from "../../model/tokens/SDKStringToken";
+import { AnyMultiLayerToken, AnySingleLayerToken, AnyToken, BorderWidthTokenValue, ColorTokenValue, ColorValue, DimensionTokenValue, DurationTokenValue, FontFamilyTokenValue, FontSizeTokenValue, FontWeightTokenValue, LetterSpacingTokenValue, LineHeightTokenValue, OpacityTokenValue, ParagraphSpacingTokenValue, ProductCopyTokenValue, RadiusTokenValue, RawValue, SizeTokenValue, SpaceTokenValue, StringTokenValue, TextCaseTokenValue, TextDecorationTokenValue, VisibilityTokenValue, ZIndexTokenValue } from "../../model/tokens/SDKTokenValue";
+export declare class AreaTokenValues {
+    /** Creates a new theme with updated overrides */
+    tokenThemeByUpdatingOverride(theme: TokenTheme, override: AnyToken): TokenTheme;
+    /** Creates a new theme with removed override */
+    tokenThemeByRemovingOverride(theme: TokenTheme, tokenId: string): TokenTheme;
+    /** Creates a new color token with updated .color value */
+    colorTokenByUpdatingColor(token: ColorToken, newValue: ColorValue | ColorToken): ColorToken;
+    /** Creates a new color token with updated .opacity value */
+    colorTokenByUpdatingOpacity(token: ColorToken, newValue: number | OpacityToken): ColorToken;
+    /** Creates a new blur token with updated .type value */
+    blurTokenByUpdatingType(token: BlurToken, newValue: BlurType): BlurToken;
+    /** Creates a new blur token with updated .radius value */
+    blurTokenByUpdatingRadius(token: BlurToken, newValue: RawValue<DimensionTokenValue> | RadiusToken): BlurToken;
+    /** Creates a new typography token with updated .fontFamily value */
+    typographyTokenByUpdatingFontFamily(token: TypographyToken, newValue: RawValue<FontFamilyTokenValue> | FontFamilyToken): TypographyToken;
+    /** Creates a new typography token with updated .fontWeight value */
+    typographyTokenByUpdatingFontWeight(token: TypographyToken, newValue: RawValue<FontWeightTokenValue> | FontWeightToken): TypographyToken;
+    /** Creates a new typography token with updated .fontSize value */
+    typographyTokenByUpdatingFontSize(token: TypographyToken, newValue: RawValue<FontSizeTokenValue> | FontSizeToken): TypographyToken;
+    /** Creates a new typography token with updated .letterSpacing value */
+    typographyTokenByUpdatingLetterSpacing(token: TypographyToken, newValue: RawValue<LetterSpacingTokenValue> | LetterSpacingToken): TypographyToken;
+    /** Creates a new typography token with updated .lineHeight value */
+    typographyTokenByUpdatingLineHeight(token: TypographyToken, newValue: RawValue<LineHeightTokenValue> | LineHeightToken): TypographyToken;
+    /** Creates a new typography token with updated .paragraphSpacing value */
+    typographyTokenByUpdatingParagraphSpacing(token: TypographyToken, newValue: RawValue<ParagraphSpacingTokenValue> | ParagraphSpacingToken): TypographyToken;
+    /** Creates a new typography token with updated .paragraphSpacing value */
+    typographyTokenByUpdatingParagraphIndent(token: TypographyToken, newValue: RawValue<ParagraphSpacingTokenValue> | ParagraphSpacingToken): TypographyToken;
+    /** Creates a new border token with updated .position value */
+    typographyTokenByUpdatingTextDecoration(token: TypographyToken, newValue: RawValue<TextDecorationTokenValue> | TextDecorationToken): TypographyToken;
+    /** Creates a new border token with updated .color value. Do note, opacity is ignored */
+    borderTokenByUpdatingColor(token: BorderToken, newValue: ColorValue | ColorToken): BorderToken;
+    /** Creates a new border token with updated color.opacity value */
+    borderTokenByUpdatingOpacity(token: BorderToken, newValue: number | OpacityToken): BorderToken;
+    /** Creates a new border token with updated .width value */
+    borderTokenByUpdatingWidth(token: BorderToken, newValue: RawValue<BorderWidthTokenValue> | BorderWidthToken): BorderToken;
+    /** Creates a new border token with updated .position value */
+    borderTokenByUpdatingPosition(token: BorderToken, newValue: BorderPosition): BorderToken;
+    /** Creates a new border token with updated .style value */
+    borderTokenByUpdatingStyle(token: BorderToken, newValue: BorderStyle): BorderToken;
+    /** Creates a new dimension token with updated value */
+    dimensionTokenByUpdatingValue(token: DimensionToken, newValue: RawValue<DimensionTokenValue>): DimensionToken;
+    /** Creates a new size token with updated value */
+    sizeTokenByUpdatingValue(token: SizeToken, newValue: RawValue<SizeTokenValue>): SizeToken;
+    /** Creates a new space token with updated value */
+    spaceTokenByUpdatingValue(token: SpaceToken, newValue: RawValue<SpaceTokenValue>): SpaceToken;
+    /** Creates a new opacity token with updated value */
+    opacityTokenByUpdatingValue(token: OpacityToken, newValue: RawValue<OpacityTokenValue>): OpacityToken;
+    /** Creates a new font size token with updated value */
+    fontSizeTokenByUpdatingValue(token: FontSizeToken, newValue: RawValue<FontSizeTokenValue>): FontSizeToken;
+    /** Creates a new font size token with updated value */
+    lineHeightTokenByUpdatingValue(token: LineHeightToken, newValue: RawValue<LineHeightTokenValue>): LineHeightToken;
+    /** Creates a new letter spacing token with updated value */
+    letterSpacingTokenByUpdatingValue(token: LetterSpacingToken, newValue: RawValue<LetterSpacingTokenValue>): LetterSpacingToken;
+    /** Creates a new paragraph spacing token with updated value */
+    paragraphSpacingTokenByUpdatingValue(token: ParagraphSpacingToken, newValue: RawValue<ParagraphSpacingTokenValue>): ParagraphSpacingToken;
+    /** Creates a new border width token with updated value */
+    borderWidthTokenByUpdatingValue(token: BorderWidthToken, newValue: RawValue<BorderWidthTokenValue>): BorderWidthToken;
+    /** Creates a new radius token with updated value */
+    radiusTokenByUpdatingValue(token: RadiusToken, newValue: RawValue<RadiusTokenValue>): RadiusToken;
+    /** Creates a new duration token with updated value */
+    durationTokenByUpdatingValue(token: DurationToken, newValue: RawValue<DurationTokenValue>): DurationToken;
+    /** Creates a new z-index token with updated value */
+    zIndexTokenByUpdatingValue(token: ZIndexToken, newValue: RawValue<ZIndexTokenValue>): ZIndexToken;
+    /** Creates a new string token with updated value */
+    stringTokenByUpdatingValue(token: StringToken, newValue: RawValue<StringTokenValue>): StringToken;
+    /** Creates a new product copy token with updated value */
+    productCopyTokenByUpdatingValue(token: ProductCopyToken, newValue: RawValue<ProductCopyTokenValue>): ProductCopyToken;
+    /** Creates a new font family token with updated value */
+    fontFamilyTokenByUpdatingValue(token: FontFamilyToken, newValue: RawValue<FontFamilyTokenValue>): FontFamilyToken;
+    /** Creates a new font weight token with updated value */
+    fontWeightTokenByUpdatingValue(token: FontWeightToken, newValue: RawValue<FontWeightTokenValue>): FontWeightToken;
+    /** Creates a new text case token with updated value */
+    textCaseTokenByUpdatingValue(token: TextCaseToken, newValue: RawValue<TextCaseTokenValue>): TextCaseToken;
+    /** Creates a new text case token with updated value */
+    textDecorationTokenByUpdatingValue(token: TextDecorationToken, newValue: RawValue<TextDecorationTokenValue>): TextDecorationToken;
+    /** Creates a new visibility token with updated value */
+    visibilityTokenByUpdatingValue(token: VisibilityToken, newValue: RawValue<VisibilityTokenValue>): VisibilityToken;
+    /** Creates a new shadow token with one new extra layer added at the end of all layers */
+    shadowTokenByAddingLayer(token: ShadowToken): ShadowToken;
+    /** Creates a new shadow token by removing one of the layers */
+    shadowTokenByRemovingLayer(token: ShadowToken, layerIndex: number): ShadowToken;
+    /** Creates a new shadow token with updated .color value. Do note, opacity is ignored */
+    shadowTokenByUpdatingColor(token: ShadowToken, layerIndex: number, newValue: ColorValue | ColorToken): ShadowToken;
+    /** Creates a new shadow token with updated .color value */
+    shadowTokenByUpdatingOpacity(token: ShadowToken, layerIndex: number, newValue: number | OpacityToken): ShadowToken;
+    /** Creates a new shadow token with updated .x value */
+    shadowTokenByUpdatingX(token: ShadowToken, layerIndex: number, newValue: number): ShadowToken;
+    /** Creates a new shadow token with updated .y value */
+    shadowTokenByUpdatingY(token: ShadowToken, layerIndex: number, newValue: number): ShadowToken;
+    /** Creates a new shadow token with updated .radius value */
+    shadowTokenByUpdatingRadius(token: ShadowToken, layerIndex: number, newValue: number): ShadowToken;
+    /** Creates a new shadow token with updated .spread value */
+    shadowTokenByUpdatingSpread(token: ShadowToken, layerIndex: number, newValue: number): ShadowToken;
+    /** Creates a new shadow token with updated .type value */
+    shadowTokenByUpdatingType(token: ShadowToken, layerIndex: number, newValue: ShadowType): ShadowToken;
+    /** Creates a new gradient token with updated .to value */
+    gradientTokenByUpdatingTo(token: GradientToken, layerIndex: number, newValue: {
+        x: number;
+        y: number;
+    }): GradientToken;
+    /** Creates a new gradient token with updated .from value */
+    gradientTokenByUpdatingFrom(token: GradientToken, layerIndex: number, newValue: {
+        x: number;
+        y: number;
+    }): GradientToken;
+    /** Creates a new gradient token with updated .to value */
+    gradientTokenByUpdatingType(token: GradientToken, layerIndex: number, newValue: GradientType): GradientToken;
+    /** Creates a new gradient token with updated .aspectRatio value */
+    gradientTokenByUpdatingAspectRatio(token: GradientToken, layerIndex: number, newValue: number): GradientToken;
+    /** Creates a new gradient token with updated .to value */
+    gradientTokenByUpdatingStops(token: GradientToken, layerIndex: number, newValue: Array<{
+        position: number;
+        color: ColorTokenValue | ColorToken;
+    }>): GradientToken;
+    /** Builds the gradient stop data from the elementary values */
+    private gradientStopsFromRawData;
+    /** Creates a new token where value is reference to the provided token. Token and reference must be of the same type */
+    tokenByReferencing<T extends AnyToken>(token: T, reference: T): T;
+    /** Creates a new multilayer token where one of the layers is reference to the provided token. Token and reference must be of the same type */
+    multilayerTokenByReferencing<T extends AnyMultiLayerToken>(token: T, layerIndex: number, reference: T): T;
+    /** Creates a new token where value is raw, but taken from the previously referenced token. Token must have had reference before */
+    tokenByDisconnectingReference<T extends AnySingleLayerToken>(token: T): T;
+    /** Creates a new multilayer token where one of the layers value is raw, but taken from the previously referenced token. That layer must have had reference before */
+    multilayerTokenByDisconnectingReference<T extends AnySingleLayerToken>(token: T, layerIndex: number): T;
+    /** Checks if token as a whole is a reference to another token */
+    isReferencedToken(token: AnySingleLayerToken): boolean;
+    /** Checks if a token layer of multilayer token is a reference to another token */
+    isReferencedMultilayerTokenLayer(token: AnyMultiLayerToken, layerIndex: number): boolean;
+    /** Checks if a token was imported from some foreign source. Not imported tokens were always created in Supernova */
+    isTokenImported(token: AnyToken): boolean;
+    private checkNotReference;
+    private rawOrReferencedDimensionValue;
+    private rawOrReferencedStringValue;
+    private validateLayerAccess;
+}