@supernova-studio/supernova-sdk-beta 0.7.17

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

@@ -0,0 +1,46 @@
+import { DTOFigmaNode } from "@supernova-studio/client";
+import { DocsImageRef, ResourceAsset, ResourceFont } from "../../exports";
+import { DataCore } from "../data/SDKDataCore";
+import { RemoteVersionIdentifier } from "./SDKRemoteIdentifiers";
+export declare class AreaResources {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Fetches all remote asset resources in the version
+     * @param from - Remote version to fetch from
+     * @returns All image resources in the specified version
+     */
+    getAssetResources(from: RemoteVersionIdentifier): Promise<Array<ResourceAsset>>;
+    /** Fetches all remote font resources in the version
+     * @param from - Remote version to fetch from
+     * @returns All font resources in the specified version
+     */
+    getFontResources(from: RemoteVersionIdentifier): Promise<Array<ResourceFont>>;
+    /** Fetches all Figma frames that were rendered font resources in the version
+     * @param from - Remote version to fetch from
+     * @returns All font resources in the specified version
+     */
+    getFigmaFrames(from: RemoteVersionIdentifier): Promise<Array<DTOFigmaNode>>;
+    /**
+     * @param from - Remote version to fetch from
+     * @param frameReferenceId  - Unique stable identifier of the Figma frame (Supernova id, not Figma id)
+     * @returns URL of the hosted image of the Figma frame that is stable across updates
+     */
+    getFigmaFrameHostedUrl(from: RemoteVersionIdentifier, frameReferenceId: string): string;
+    /** Retrieves stable URL
+     * @param from - Remote version to fetch from
+     * @param frameReferenceId  - Unique stable identifier of the Figma frame (Supernova id, not Figma id)
+     * @returns URL of the hosted image resource, either uploaded file or Figma frame
+     */
+    getImageRefHostedUrl(from: RemoteVersionIdentifier, imageRef: DocsImageRef | undefined): string | undefined;
+    /** Uploads new asset resource */
+    uploadAssetResource(from: RemoteVersionIdentifier, asset: File): Promise<ResourceAsset>;
+    /** Uploads new font resource */
+    uploadFontResource(from: RemoteVersionIdentifier, font: File): Promise<ResourceFont | null>;
+    /** Uploads new font resources */
+    uploadFontResources(from: RemoteVersionIdentifier, fonts: FileList): Promise<ResourceFont[]>;
+    /** Deletes single resource of any type */
+    deleteResource(from: RemoteVersionIdentifier, resourceId: string): Promise<void>;
+    /** Deletes multiple resource of any type */
+    deleteResources(from: RemoteVersionIdentifier, resourceIds: string[]): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+import { DataCore } from "../data/SDKDataCore";
+export declare class AreaStorage {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** Read data from key-value storage
+     * @param designSystemId - Design system ID to read the data from
+     * @param key - Unique data key to read
+     */
+    readKeyValueStorageData(designSystemId: string, key: string): Promise<string | object | null>;
+    /** Set data to key-value storage. Limit of 20mb per a design system.
+     * @param designSystemId - Design system ID to store data for
+     * @param key - Unique data key under which the data will be stored
+     * @param value - String or object to be stored. Anything else must be converted to JSON string first
+     * @returns Nothing
+     */
+    setKeyValueStorageData(designSystemId: string, key: string, value: string | object): Promise<void>;
+    /** Unsets the data from key-value storage based on the key name
+     * @param designSystemId - Design system ID to remove the data from
+     * @param key - Unique data key to delete
+     */
+    unsetKeyValueStorageData(designSystemId: string, key: string): Promise<void>;
+}

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

@@ -0,0 +1,136 @@
+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 typography token with updated .textCase value */
+    typographyTokenByUpdatingTextCase(token: TypographyToken, newValue: RawValue<TextCaseTokenValue> | TextCaseToken): 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;
+    /** 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, R extends T>(token: T, layerIndex: number, reference: R): 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;
+}

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

@@ -0,0 +1,225 @@
+import { AnyToken } from "../../exports";
+import { ElementDataView } from "../../model/elements/SDKElementDataView";
+import { ElementDataViewColumn } from "../../model/elements/SDKElementDataViewColumn";
+import { ElementProperty, ElementPropertyCreationModel, ElementPropertyUpdateModel } from "../../model/elements/SDKElementProperty";
+import { ElementPropertyValue } from "../../model/elements/values/SDKElementPropertyValue";
+import { TokenType } from "../../model/enums/SDKTokenType";
+import { TokenGroup } from "../../model/groups/SDKTokenGroup";
+import { TokenTheme } from "../../model/themes/SDKTokenTheme";
+import { Token } from "../../model/tokens/SDKToken";
+import { TokenTypeMapToken } from "../../utils/TokenUtils";
+import { DataCore } from "../data/SDKDataCore";
+import { AreaTokenValues } from "./SDKAreaTokenValues";
+import { RemoteBrandIdentifier, RemoteVersionIdentifier } from "./SDKRemoteIdentifiers";
+export declare class AreaTokens {
+    /** Internal: Engine */
+    private dataCore;
+    /** Update helpers for everything token related */
+    values: AreaTokenValues;
+    constructor(dataCore: DataCore);
+    /** Fetches all remote tokens in the version
+     * @param from - Remote version to fetch from
+     * @param filter - Optional filter to apply. Multiple filters can be used at once
+     * @param filter.type - When provided, only tokens of the specified type will be returned
+     * @param filter.brandId - When provided, only tokens of the specified brand will be returned
+     * @returns Tokens in the specified version with filter applied
+     */
+    getTokens(from: RemoteVersionIdentifier, filter?: {
+        type?: TokenType;
+        brandId?: string;
+    }): Promise<Array<Token>>;
+    /** Retrieves all occurances of the specified token in the version - its usages in other tokens, components and documentation pages
+     * @param from - Remote version to fetch from
+     * @param idInVersion - Token to check for references
+     * @returns Persistent identifiers of tokens, components, documentation pages that contain the specified token
+     */
+    getTokenUsage(from: RemoteVersionIdentifier, idInVersion: string): Promise<{
+        tokens: Array<string>;
+        components: Array<string>;
+        documentationPages: Array<string>;
+    }>;
+    /** Fetches all remote token groups in this version
+     * @param from - Remote version to fetch from
+     * @param filter - Optional filter to apply. Multiple filters can be used at once
+     * @param filter.type - When provided, only token groups of the specified type will be returned
+     * @param filter.brandId - When provided, only token groups of the specified brand will be returned
+     * @returns Token groups in the specified version with filter applied
+     */
+    getTokenGroups(from: RemoteVersionIdentifier, filter?: {
+        type?: TokenType;
+        brandId?: string;
+    }): Promise<Array<TokenGroup>>;
+    /** Fetches all remote themes in the version
+     * @param from - Remote version to fetch from
+     * @returns All themes in the specified version
+     */
+    getTokenThemes(from: RemoteVersionIdentifier): Promise<Array<TokenTheme>>;
+    /** Retrieves all remote property definitions for tokens
+     * @param from - Remote version to fetch from
+     * @returns All property definitions in the specified version
+     */
+    getTokenProperties(from: RemoteVersionIdentifier): Promise<Array<ElementProperty>>;
+    /** Retrieves all remote property definitions for tokens
+     * @param from - Remote version to fetch from
+     * @returns All property definitions in the specified version
+     */
+    getTokenPropertyValues(from: RemoteVersionIdentifier): Promise<Array<ElementPropertyValue>>;
+    /** Retrieves all remote property views for tokens
+     * @param from - Remote version to fetch from
+     * @returns All property views in the specified version
+     */
+    getTokenDataViews(from: RemoteVersionIdentifier): Promise<Array<ElementDataView>>;
+    /** Creates remote token. This method can only be used once per token and will assign persistent id to the token. Calling this version on token that already has id assigned will result in error
+     * @param to - Remote version to write to
+     * @param token - Token to create
+     * @param parentId - Id of the group to add the token to. This is id of the group, not the versioned id
+     * @returns New remote token ids
+     */
+    createToken(to: RemoteVersionIdentifier, token: Token, parentId: string): Promise<{
+        id: string;
+        idInVersion: string;
+    }>;
+    /** Creates local token. This token doesn't have id associated with it on remote, and must be created once with `createToken` to be stored in design system
+     * @param tokenType - Type of token to create
+     * @returns New token of the specified type, filled with default values
+     */
+    createLocalToken<T extends TokenType>(tokenType: T, versionId: string, brandId: string, properties: Array<ElementProperty>): TokenTypeMapToken[T];
+    /** Creates local token override. This theme override doesn't have id associated with it on remote, and must be created once with `createThemeOverride` to be stored in design system
+     * @param tokenType - Type of token to create
+     * @returns New token of the specified type, filled with default values
+     */
+    createLocalThemeOverride<T extends AnyToken>(theme: TokenTheme, baseToken: T): T;
+    /** Creates remote token group. This method can only be used once per group and will assign persistent id to the group. Calling this version on group that already has id assigned will result in error
+     * @param to - Remote version to write to
+     * @param group - Group to create
+     * @param parentId - Id of the group to add the group to. This is id of the group, not the versioned id
+     * @returns New remote token group ids
+     */
+    createTokenGroup(to: RemoteVersionIdentifier, group: TokenGroup, parentId: string): Promise<{
+        id: string;
+        idInVersion: string;
+    }>;
+    /** Creates local token group. This group doesn't have id associated with it on remote, and must be created once with `createTokenGroup` to be stored in design system
+     * @param tokenType - Type of token to create the group for
+     * @param versionId - Id of the version to create the group in
+     * @param brandId - Id of the brand to create the group in
+     * @returns New group with id assigned
+     */
+    createLocalTokenGroup(tokenType: TokenType, versionId: string, brandId: string): TokenGroup;
+    /** Updates remote token. This method can only be used on tokens that already exist in the version
+     * @param to - Remote version to write to
+     * @param token - Token to update
+     * @returns Nothing
+     */
+    updateToken(to: RemoteVersionIdentifier, token: Token): Promise<void>;
+    /** Updates remote token groups. This method can only be used on token groups that already exist in the version
+     * @param to - Remote version to write to
+     * @param token - Token group to update
+     * @returns Nothing
+     */
+    updateTokenGroup(to: RemoteVersionIdentifier, group: TokenGroup): Promise<void>;
+    /** Updates remote token property value. This also creates the property value if it doesn't exist
+     * @param to - Remote version to write to
+     * @param newValue - Value to set - this can be multiple things, from ID to raw string value to others
+     * @param forToken - Token to assign the value to
+     * @param forProperty - Property to assign the value to
+     */
+    updateTokenPropertyValue(to: RemoteVersionIdentifier, newValue: string, forToken: Token, forProperty: ElementProperty): Promise<void>;
+    /** Deletes remote token property value
+     * @param to - Remote version to write to
+     * @param valueId - Value identifier
+     */
+    deleteTokenPropertyValue(to: RemoteVersionIdentifier, valueId: string): Promise<void>;
+    /** Create token property
+     * @param to - Remote version to write to
+     * @param model - Property creation model to create the property from
+     */
+    createTokenProperty(to: RemoteVersionIdentifier, model: ElementPropertyCreationModel): Promise<{
+        id: string;
+        idInVersion: string;
+    }>;
+    /** Update token property
+     * @param to - Remote version to write to
+     * @param propertyIdInVersion - Remote element property to update
+     * @param model - Property update model to apply to property
+     */
+    updateTokenProperty(to: RemoteVersionIdentifier, propertyIdInVersion: string, model: ElementPropertyUpdateModel): Promise<void>;
+    /** Delete token property. This will remove all values associated with the property
+     * @param to - Remote version to write to
+     * @param propertyIdInVersion - Id of the property to delete
+     */
+    deleteTokenProperty(to: RemoteVersionIdentifier, propertyIdInVersion: string): Promise<void>;
+    /** Resize specific token column
+     * @param to - Remote version to write to
+     * @param columnIdInVersion - Id of the column to update
+     * @param newWidth - New width of the column
+     */
+    updateResizeTokenColumn(to: RemoteVersionIdentifier, view: ElementDataView, column: ElementDataViewColumn, newWidth: number): Promise<void>;
+    /** Move column to a new index and reorder all other columns around it
+     * @param to - Remote version to write to
+     * @param colum - Column object to move
+     * @param newIndex - New index to move the token to
+     */
+    updateReorderTokenColumn(to: RemoteVersionIdentifier, view: ElementDataView, column: ElementDataViewColumn, newIndex: number): Promise<void>;
+    /** Creates local token theme. This group doesn't have id associated with it on remote, and must be created once with `createTokenTheme` to be stored in design system
+     * @param versionId - Id of the version to create the theme in
+     * @param brandId - Id of the brand to create the theme in
+     * @returns New group with id assigned
+     */
+    createLocalTokenTheme(versionId: string, brandId: string): TokenTheme;
+    /** Creates remote token theme. This method can only be used once per theme and will assign persistent id to the theme. Calling this version on theme that already has id assigned will result in error
+     * @param to - Remote version to write to
+     * @param theme - Theme to create
+     * @returns New remote theme ids
+     */
+    createTokenTheme(to: RemoteVersionIdentifier, theme: TokenTheme): Promise<{
+        id: string;
+        idInVersion: string;
+    }>;
+    /** Updates token theme. This method can only be used on themes that already exist in the version
+     * @param to - Remote version to write to
+     * @param theme - Token theme to update
+     * @returns Nothing
+     */
+    updateTokenTheme(to: RemoteVersionIdentifier, theme: TokenTheme): Promise<void>;
+    /** Deletes remote token. Calling this method on token that doesn't exist in the version will result in error
+     * @param to - Remote version to write to
+     * @param tokenIdInVersion - Token idInVersion to delete
+     * @returns Nothing
+     */
+    deleteToken(to: RemoteVersionIdentifier, tokenIdInVersion: string): Promise<void>;
+    /** Deletes remote token group. This method will also fix the token group tree by moving any subgroups to parent - do note it will NOT delete contents of the group. Calling this method on group that doesn't exist in the version will result in error
+     * @param to - Remote version to write to
+     * @param tokenGroupIdInVersion - Token group idInVersion to delete
+     * @returns Nothing
+     */
+    ungroupTokenGroup(to: RemoteVersionIdentifier, tokenGroupIdInVersion: string): Promise<void>;
+    /** Deletes remote token group and all its descendants. All items (groups and tokens) underneath will be deleted. Calling this method on group that doesn't exist in the version will result in error
+     * @param to - Remote version to write to
+     * @param tokenGroupToDelete - Token group to delete
+     * @param tokens - All available tokens
+     * @param tokenGroups - All available token groups
+     * @returns Nothing
+     */
+    deleteTokenGroup(to: RemoteVersionIdentifier, tokenGroupToDelete: TokenGroup, tokens: Array<Token>, tokenGroups: Array<TokenGroup>): Promise<void>;
+    /** Deletes remote token theme. This method will also remove all theme overrides and disconnect theme from assigned column, all of which will be updated
+     * @param to - Remote version to write to
+     * @param idInVersion - Theme idInVersion to delete
+     * @returns Nothing
+     */
+    deleteTokenTheme(to: RemoteVersionIdentifier, idInVersion: string): Promise<void>;
+    /** Warning: INTERNAL, DO NOT USE YET, NOT STABLE INTERFACE. Write tokens in bulk */
+    writeTokens(to: RemoteVersionIdentifier, tokens: Array<Token>, groups: Array<TokenGroup>, deleteTokens: Array<Token>, deleteTokenGroups: Array<TokenGroup>): Promise<void>;
+    /** Warning: INTERNAL, DO NOT USE YET, NOT STABLE INTERFACE. Write theme in bulk */
+    writeTheme(to: RemoteVersionIdentifier, theme: TokenTheme): Promise<void>;
+    /** Resolves tokens by applying themes to them and retrieves new token set where values correctly correspond to that theme */
+    computeTokensByApplyingThemes(tokens: Array<Token>, themes: Array<TokenTheme>): Promise<Array<Token>>;
+    /** Separates groups by types */
+    computeGroupTrees(groups: Array<TokenGroup>): Promise<Map<TokenType, Array<TokenGroup>>>;
+    /** Get determistic mocked token data. Must be used with mocked token groups */
+    getMockedTokens(from: RemoteBrandIdentifier): Promise<Array<Token>>;
+    /** Get determistic mocked token group data. Must be used with mocked tokens */
+    getMockedTokenGroups(from: RemoteBrandIdentifier): Promise<Array<TokenGroup>>;
+    /** Get determistic mocked token data views. Must be used with mocked tokens */
+    getMockedTokenDataViews(from: RemoteVersionIdentifier): Promise<Array<ElementDataView>>;
+}

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

@@ -0,0 +1,6 @@
+import { DataCore } from "../data/SDKDataCore";
+export declare class AreaUsers {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+}

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

@@ -0,0 +1,35 @@
+import { DesignSystemVersion, DesignSystemVersionUpdateModel } from "../../model/base/SDKDesignSystemVersion";
+import { DataCore } from "../data/SDKDataCore";
+import { RemoteVersionIdentifier } from "./SDKRemoteIdentifiers";
+export declare class AreaVersions {
+    /** Internal: Engine */
+    private dataCore;
+    constructor(dataCore: DataCore);
+    /** 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. */
+    getActiveVersion(designSystemId: string): Promise<DesignSystemVersion | null>;
+    /** Creates new version and retrieves the newly created version object.
+     * @param designSystemId - ID of the design system
+     * @param model - new version model
+     * @returns Newly created version object
+     */
+    createVersion(designSystemId: string, model: DesignSystemVersionUpdateModel): Promise<DesignSystemVersion>;
+    /** Edits version
+     * @param designSystemId - ID of the design system
+     * @param versionId - ID of version
+     * @param model - new version model
+     * @returns nothing
+     */
+    editVersion(designSystemId: string, versionId: string, model: DesignSystemVersionUpdateModel): Promise<void>;
+    /** Deletes version
+     * @param designSystemId - ID of the design system
+     * @param versionId - ID of version
+     * @returns nothing
+     */
+    deleteVersion(designSystemId: string, versionId: string): Promise<void>;
+    /** Fetches all design system versions of provided design system */
+    getVersions(designSystemId: string): Promise<Array<DesignSystemVersion>>;
+    /** Fetches design system version by id */
+    getVersion(from: RemoteVersionIdentifier): Promise<DesignSystemVersion>;
+    getTokenStudioData(from: RemoteVersionIdentifier): Promise<object>;
+    writeTokenStudioData(from: RemoteVersionIdentifier, data: object): Promise<object>;
+}