@supernova-studio/supernova-sdk-beta 0.7.17

package/build/sdk-typescript/src/model/tokens/SDKDimensionToken.d.ts

@@ -0,0 +1,104 @@
+import { DTTokenReferenceResolver } from "../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver";
+import { TokenClassTypeMapToken } from "../../utils/TokenUtils";
+import { ElementProperty } from "../elements/SDKElementProperty";
+import { ElementPropertyValue } from "../elements/values/SDKElementPropertyValue";
+import { DimensionTokenType, TokenType } from "../enums/SDKTokenType";
+import { Unit } from "../enums/SDKUnit";
+import { DimensionTokenRemoteModel, TokenRemoteModel } from "./remote/SDKRemoteTokenModel";
+import { AnyDimensionTokenRemoteValue } from "./remote/SDKRemoteTokenValue";
+import { Token } from "./SDKToken";
+import { AnyDimensionTokenValue, BorderWidthTokenValue, DimensionTokenValue, DurationTokenValue, FontSizeTokenValue, LetterSpacingTokenValue, LineHeightTokenValue, OpacityTokenValue, ParagraphSpacingTokenValue, RadiusTokenValue, SizeTokenValue, SpaceTokenValue, ZIndexTokenValue } from "./SDKTokenValue";
+export declare class DimensionCategoryToken<T extends AnyDimensionTokenValue> extends Token {
+    value: T;
+    constructor(versionId: string, baseToken: TokenRemoteModel, value: T, alias: DimensionCategoryToken<T> | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create<TValue extends AnyDimensionTokenValue, TToken extends DimensionCategoryToken<TValue>>(this: new (...args: any[]) => TToken, type: DimensionTokenType, versionId: string, brandId: string, name: string, description: string, value: string | number, alias: TToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): TToken;
+    static getCompatibleUnit(unit: Unit, type: DimensionTokenType): Unit;
+    static getCompatibleMeasure(unit: Unit, type: DimensionTokenType, measure: number): number;
+    static getDefaultUnit(type: DimensionTokenType, parsedDefinition?: number): Unit.pixels | Unit.ms | Unit.raw;
+    static dimensionValueFromDefinition(definition: string | number, type: DimensionTokenType): OpacityTokenValue;
+    static parseDimension(definition: string, type: DimensionTokenType): {
+        measure: number;
+        unit: Unit;
+    };
+    static dimensionValueFromDefinitionOrReference(definition: any, referenceResolver: DTTokenReferenceResolver, tokenType: DimensionTokenType): BorderWidthTokenValue;
+    toString(): string;
+    static valueToString(value: AnyDimensionTokenValue, options?: {
+        maxNumberOfDecimals?: number;
+        clipTrailingZeroes?: boolean;
+    }): string;
+    static numberToString(value: number, options?: {
+        maxNumberOfDecimals?: number;
+        clipTrailingZeroes?: boolean;
+    }): string;
+    static unitToString(unit: Unit): string;
+    toWriteObject(): DimensionTokenRemoteModel;
+    static valueToWriteObject(value: AnyDimensionTokenValue): {
+        aliasTo: string | undefined;
+        value: AnyDimensionTokenRemoteValue;
+    };
+    static valueToInternalWriteObject(value: AnyDimensionTokenValue | null): AnyDimensionTokenValue | null;
+}
+export declare class DimensionToken extends DimensionCategoryToken<DimensionTokenValue> {
+    tokenType: TokenType.dimension;
+}
+export declare class SizeToken extends DimensionCategoryToken<SizeTokenValue> {
+    tokenType: TokenType.size;
+}
+export declare class SpaceToken extends DimensionCategoryToken<SpaceTokenValue> {
+    tokenType: TokenType.space;
+}
+export declare class OpacityToken extends DimensionCategoryToken<OpacityTokenValue> {
+    tokenType: TokenType.opacity;
+}
+export declare class FontSizeToken extends DimensionCategoryToken<FontSizeTokenValue> {
+    tokenType: TokenType.fontSize;
+}
+export declare class LineHeightToken extends DimensionCategoryToken<LineHeightTokenValue> {
+    tokenType: TokenType.lineHeight;
+}
+export declare class LetterSpacingToken extends DimensionCategoryToken<LetterSpacingTokenValue> {
+    tokenType: TokenType.letterSpacing;
+}
+export declare class ParagraphSpacingToken extends DimensionCategoryToken<ParagraphSpacingTokenValue> {
+    tokenType: TokenType.paragraphSpacing;
+}
+export declare class BorderWidthToken extends DimensionCategoryToken<BorderWidthTokenValue> {
+    tokenType: TokenType.borderWidth;
+}
+export declare class RadiusToken extends DimensionCategoryToken<RadiusTokenValue> {
+    tokenType: TokenType.radius;
+}
+export declare class DurationToken extends DimensionCategoryToken<DurationTokenValue> {
+    tokenType: TokenType.duration;
+}
+export declare class ZIndexToken extends DimensionCategoryToken<ZIndexTokenValue> {
+    tokenType: TokenType.zIndex;
+}
+export type AnyDimensionToken = DimensionToken | SizeToken | SpaceToken | OpacityToken | FontSizeToken | LineHeightToken | LetterSpacingToken | ParagraphSpacingToken | BorderWidthToken | RadiusToken | DurationToken | ZIndexToken;
+export declare const resolveDimension: <TK extends TokenType.radius | TokenType.borderWidth | TokenType.duration | TokenType.fontSize | TokenType.dimension | TokenType.letterSpacing | TokenType.lineHeight | TokenType.opacity | TokenType.paragraphSpacing | TokenType.size | TokenType.space | TokenType.zIndex>(type: TK) => {
+    Color: typeof import("./SDKColorToken").ColorToken;
+    Typography: typeof import("./SDKTypographyToken").TypographyToken;
+    Blur: typeof import("./SDKBlurToken").BlurToken;
+    Border: typeof import("./SDKBorderToken").BorderToken;
+    Shadow: typeof import("./SDKShadowToken").ShadowToken;
+    Gradient: typeof import("./SDKGradientToken").GradientToken;
+    String: typeof import("./SDKStringToken").StringToken;
+    ProductCopy: typeof import("./SDKStringToken").ProductCopyToken;
+    FontFamily: typeof import("./SDKStringToken").FontFamilyToken;
+    FontWeight: typeof import("./SDKStringToken").FontWeightToken;
+    TextCase: typeof import("./SDKTextCaseToken").TextCaseToken;
+    TextDecoration: typeof import("./SDKTextDecorationToken").TextDecorationToken;
+    Visibility: typeof import("./SDKVisibilityToken").VisibilityToken;
+    BorderWidth: typeof BorderWidthToken;
+    Dimension: typeof DimensionToken;
+    Size: typeof SizeToken;
+    Space: typeof SpaceToken;
+    Opacity: typeof OpacityToken;
+    FontSize: typeof FontSizeToken;
+    LineHeight: typeof LineHeightToken;
+    LetterSpacing: typeof LetterSpacingToken;
+    ParagraphSpacing: typeof ParagraphSpacingToken;
+    BorderRadius: typeof RadiusToken;
+    Duration: typeof DurationToken;
+    ZIndex: typeof ZIndexToken;
+}[TK];

package/build/sdk-typescript/src/model/tokens/SDKGradientToken.d.ts

@@ -0,0 +1,26 @@
+import { DTTokenReferenceResolver } from "../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver";
+import { ElementProperty } from "../elements/SDKElementProperty";
+import { ElementPropertyValue } from "../elements/values/SDKElementPropertyValue";
+import { TokenType } from "../enums/SDKTokenType";
+import { GradientTokenRemoteData } from "./remote/SDKRemoteTokenData";
+import { GradientTokenRemoteModel, TokenRemoteModel } from "./remote/SDKRemoteTokenModel";
+import { GradientTokenRemoteValue } from "./remote/SDKRemoteTokenValue";
+import { Token } from "./SDKToken";
+import { GradientTokenValue } from "./SDKTokenValue";
+export declare class GradientToken extends Token {
+    value: GradientTokenValue[];
+    gradientLayers: Array<GradientToken>;
+    isVirtual: boolean;
+    tokenType: TokenType.gradient;
+    constructor(versionId: string, baseToken: TokenRemoteModel, value: GradientTokenValue[], alias: GradientToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(versionId: string, brandId: string, name: string, description: string, value: string, alias: GradientToken | null, referenceResolver: DTTokenReferenceResolver, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): GradientToken;
+    static gradientValueFromDefinition(definition: object | string, referenceResolver: DTTokenReferenceResolver): GradientTokenValue[];
+    static gradientSingleValueFromDefinition(definition: string, referenceResolver: DTTokenReferenceResolver): GradientTokenValue;
+    static gradientValueFromDefinitionOrReference(definition: any, referenceResolver: DTTokenReferenceResolver): GradientTokenValue[] | undefined;
+    toWriteObject(): GradientTokenRemoteModel;
+    static valueToWriteObject(value: GradientTokenValue[]): GradientTokenRemoteData;
+    static singleValueToWriteObject(value: GradientTokenValue): {
+        aliasTo: string | undefined;
+        value: GradientTokenRemoteValue;
+    };
+}

package/build/sdk-typescript/src/model/tokens/SDKShadowToken.d.ts

@@ -0,0 +1,26 @@
+import { DTTokenReferenceResolver } from "../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver";
+import { ElementProperty } from "../elements/SDKElementProperty";
+import { ElementPropertyValue } from "../elements/values/SDKElementPropertyValue";
+import { TokenType } from "../enums/SDKTokenType";
+import { ShadowTokenRemoteData } from "./remote/SDKRemoteTokenData";
+import { ShadowTokenRemoteModel, TokenRemoteModel } from "./remote/SDKRemoteTokenModel";
+import { ShadowTokenRemoteValue } from "./remote/SDKRemoteTokenValue";
+import { Token } from "./SDKToken";
+import { ShadowTokenValue } from "./SDKTokenValue";
+export declare class ShadowToken extends Token {
+    value: Array<ShadowTokenValue>;
+    shadowLayers: Array<ShadowToken>;
+    isVirtual: boolean;
+    tokenType: TokenType.shadow;
+    constructor(versionId: string, baseToken: TokenRemoteModel, value: ShadowTokenValue[], alias: ShadowToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(versionId: string, brandId: string, name: string, description: string, value: object, alias: ShadowToken | null, referenceResolver: DTTokenReferenceResolver, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): ShadowToken;
+    static shadowValueFromDefinition(definition: object, referenceResolver: DTTokenReferenceResolver): ShadowTokenValue[];
+    static shadowTokenColorAndOpacityToHex8(shadowTokenValue: ShadowTokenValue): string;
+    static shadowSingleValueFromDefinition(definition: object, referenceResolver: DTTokenReferenceResolver): ShadowTokenValue;
+    toWriteObject(): ShadowTokenRemoteModel;
+    static valueToWriteObject(value: ShadowTokenValue[]): ShadowTokenRemoteData;
+    static singleValueToWriteObject(value: ShadowTokenValue): {
+        aliasTo: string | undefined;
+        value: ShadowTokenRemoteValue;
+    };
+}

package/build/sdk-typescript/src/model/tokens/SDKStringToken.d.ts

@@ -0,0 +1,61 @@
+import { DTTokenReferenceResolver } from "../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver";
+import { TokenClassTypeMapToken } from "../../utils/TokenUtils";
+import { ElementProperty } from "../elements/SDKElementProperty";
+import { ElementPropertyValue } from "../elements/values/SDKElementPropertyValue";
+import { StringTokenType, TokenType } from "../enums/SDKTokenType";
+import { StringTokenRemoteModel, TokenRemoteModel } from "./remote/SDKRemoteTokenModel";
+import { StringTokenRemoteValue } from "./remote/SDKRemoteTokenValue";
+import { Token } from "./SDKToken";
+import { AnyStringTokenValue, FontFamilyTokenValue, FontWeightTokenValue, ProductCopyTokenValue, StringTokenValue } from "./SDKTokenValue";
+export declare class StringCategoryToken<T extends AnyStringTokenValue> extends Token {
+    value: T;
+    constructor(versionId: string, baseToken: TokenRemoteModel, value: T, alias: StringCategoryToken<T> | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create<TValue extends AnyStringTokenValue, TToken extends StringCategoryToken<TValue>>(this: new (...args: any[]) => TToken, type: StringTokenType, versionId: string, brandId: string, name: string, description: string, value: string | number, alias: TToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): TToken;
+    static stringValueFromDefinitionOrReference(definition: any, referenceResolver: DTTokenReferenceResolver, tokenType: StringTokenType): AnyStringTokenValue | undefined;
+    static stringValueFromDefinition(definition: string, tokenType: StringTokenType): AnyStringTokenValue;
+    toWriteObject(): StringTokenRemoteModel;
+    static valueToWriteObject(value: AnyStringTokenValue): {
+        aliasTo: string | undefined;
+        value: StringTokenRemoteValue;
+    };
+}
+export declare class StringToken extends StringCategoryToken<StringTokenValue> {
+    tokenType: TokenType.string;
+}
+export declare class ProductCopyToken extends StringCategoryToken<ProductCopyTokenValue> {
+    tokenType: TokenType.productCopy;
+}
+export declare class FontFamilyToken extends StringCategoryToken<FontFamilyTokenValue> {
+    tokenType: TokenType.fontFamily;
+}
+export declare class FontWeightToken extends StringCategoryToken<FontWeightTokenValue> {
+    tokenType: TokenType.fontWeight;
+}
+export type AnyStringToken = StringToken | ProductCopyToken | FontFamilyToken | FontWeightToken;
+export declare const resolveString: <TK extends TokenType.fontFamily | TokenType.fontWeight | TokenType.string | TokenType.productCopy>(type: TK) => {
+    Color: typeof import("./SDKColorToken").ColorToken;
+    Typography: typeof import("./SDKTypographyToken").TypographyToken;
+    Blur: typeof import("./SDKBlurToken").BlurToken;
+    Border: typeof import("./SDKBorderToken").BorderToken;
+    Shadow: typeof import("./SDKShadowToken").ShadowToken;
+    Gradient: typeof import("./SDKGradientToken").GradientToken;
+    String: typeof StringToken;
+    ProductCopy: typeof ProductCopyToken;
+    FontFamily: typeof FontFamilyToken;
+    FontWeight: typeof FontWeightToken;
+    TextCase: typeof import("./SDKTextCaseToken").TextCaseToken;
+    TextDecoration: typeof import("./SDKTextDecorationToken").TextDecorationToken;
+    Visibility: typeof import("./SDKVisibilityToken").VisibilityToken;
+    BorderWidth: typeof import("./SDKDimensionToken").BorderWidthToken;
+    Dimension: typeof import("./SDKDimensionToken").DimensionToken;
+    Size: typeof import("./SDKDimensionToken").SizeToken;
+    Space: typeof import("./SDKDimensionToken").SpaceToken;
+    Opacity: typeof import("./SDKDimensionToken").OpacityToken;
+    FontSize: typeof import("./SDKDimensionToken").FontSizeToken;
+    LineHeight: typeof import("./SDKDimensionToken").LineHeightToken;
+    LetterSpacing: typeof import("./SDKDimensionToken").LetterSpacingToken;
+    ParagraphSpacing: typeof import("./SDKDimensionToken").ParagraphSpacingToken;
+    BorderRadius: typeof import("./SDKDimensionToken").RadiusToken;
+    Duration: typeof import("./SDKDimensionToken").DurationToken;
+    ZIndex: typeof import("./SDKDimensionToken").ZIndexToken;
+}[TK];

package/build/sdk-typescript/src/model/tokens/SDKTextCaseToken.d.ts

@@ -0,0 +1,23 @@
+import { ElementProperty } from "../elements/SDKElementProperty";
+import { ElementPropertyValue } from "../elements/values/SDKElementPropertyValue";
+import { TextCase } from "../enums/SDKTextCase";
+import { TokenType } from "../enums/SDKTokenType";
+import { TextCaseTokenRemoteModel, TokenRemoteModel } from "./remote/SDKRemoteTokenModel";
+import { TextCaseTokenRemoteValue } from "./remote/SDKRemoteTokenValue";
+import { Token } from "./SDKToken";
+import { TextCaseTokenValue } from "./SDKTokenValue";
+export declare class TextCaseToken extends Token {
+    value: TextCaseTokenValue;
+    tokenType: TokenType.textCase;
+    constructor(versionId: string, baseToken: TokenRemoteModel, value: TextCaseTokenValue, alias: TextCaseToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(versionId: string, brandId: string, name: string, description: string, value: string, alias: TextCaseToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): TextCaseToken;
+    static textCaseFromDefinition(textCase: string): {
+        value: TextCase;
+        referencedTokenId: null;
+    };
+    toWriteObject(): TextCaseTokenRemoteModel;
+    static valueToWriteObject(value: TextCaseTokenValue): {
+        aliasTo: string | undefined;
+        value: TextCaseTokenRemoteValue;
+    };
+}

package/build/sdk-typescript/src/model/tokens/SDKTextDecorationToken.d.ts

@@ -0,0 +1,26 @@
+import { DTTokenReferenceResolver } from "../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver";
+import { ElementProperty } from "../elements/SDKElementProperty";
+import { ElementPropertyValue } from "../elements/values/SDKElementPropertyValue";
+import { TextDecoration } from "../enums/SDKTextDecoration";
+import { OptionTokenType, TokenType } from "../enums/SDKTokenType";
+import { TextCaseTokenRemoteModel, TokenRemoteModel } from "./remote/SDKRemoteTokenModel";
+import { TextDecorationTokenRemoteValue } from "./remote/SDKRemoteTokenValue";
+import { Token } from "./SDKToken";
+import { AnyOptionTokenValue, TextDecorationTokenValue } from "./SDKTokenValue";
+export declare class TextDecorationToken extends Token {
+    value: TextDecorationTokenValue;
+    tokenType: TokenType.textDecoration;
+    constructor(versionId: string, baseToken: TokenRemoteModel, value: TextDecorationTokenValue, alias: TextDecorationToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(versionId: string, brandId: string, name: string, description: string, value: string, alias: TextDecorationToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): TextDecorationToken;
+    static textDecorationFromDefinition(textDecoration: string): {
+        value: TextDecoration;
+        referencedTokenId: null;
+    };
+    static optionValueFromDefinitionOrReference(definition: any, referenceResolver: DTTokenReferenceResolver, tokenType: OptionTokenType): AnyOptionTokenValue;
+    static optionValueFromDefinition(definition: string, type: OptionTokenType): AnyOptionTokenValue;
+    toWriteObject(): TextCaseTokenRemoteModel;
+    static valueToWriteObject(value: TextDecorationTokenValue): {
+        aliasTo: string | undefined;
+        value: TextDecorationTokenRemoteValue;
+    };
+}

package/build/sdk-typescript/src/model/tokens/SDKToken.d.ts

@@ -0,0 +1,33 @@
+import { ElementProperty } from "../elements/SDKElementProperty";
+import { ElementPropertyValue } from "../elements/values/SDKElementPropertyValue";
+import { TokenType } from "../enums/SDKTokenType";
+import { TokenOrigin } from "../support/SDKTokenOrigin";
+import { TokenRemoteModel } from "./remote/SDKRemoteTokenModel";
+import { TokenValue } from "./SDKTokenValue";
+export declare class Token implements TokenValue {
+    /** Persistent id of the token. This id never changes across versions */
+    id: string;
+    /** Version id of the token. This id changes whenever a new version is created, and each version of the token in version has different id */
+    idInVersion: string;
+    /** Persistent id of the brand. This id never changes as tokens can't be moved across the brands */
+    brandId: string;
+    themeId: string | null;
+    designSystemVersionId: string;
+    name: string;
+    description: string;
+    tokenType: TokenType;
+    origin: TokenOrigin | null;
+    parentGroupId: string;
+    sortOrder: number;
+    properties: Array<ElementProperty>;
+    propertyValues: {
+        [key: string]: string | boolean | number;
+    };
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    constructor(model: TokenRemoteModel, versionId: string, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>, empty?: boolean);
+    setParentGroupId(parentGroupId: string | null): void;
+    setSortOrder(order: number): void;
+    toBaseWriteObject(): TokenRemoteModel;
+    toWriteObject(): TokenRemoteModel;
+}

package/build/sdk-typescript/src/model/tokens/SDKTokenCompator.d.ts

@@ -0,0 +1,20 @@
+import { Token } from "./SDKToken";
+import { AnyDimensionTokenValue, AnyOptionTokenValue, AnyPlainTokenValue, AnyStringTokenValue, BlurTokenValue, BorderTokenValue, ColorTokenValue, GradientStopValue, GradientTokenValue, ShadowTokenValue, TypographyTokenValue } from "./SDKTokenValue";
+export declare class TokenComparator {
+    static isEqualTokenValue(a: Token, b: Token): boolean;
+    static referencesSameToken(a: AnyPlainTokenValue, b: AnyPlainTokenValue): boolean;
+    static anyIsReference(a: AnyPlainTokenValue, b: AnyPlainTokenValue): boolean;
+    static isUndefinedValue(a: AnyPlainTokenValue | undefined | null, b: AnyPlainTokenValue | undefined | null): boolean;
+    static isEqualBlurTokenValue(a: BlurTokenValue, b: BlurTokenValue): boolean;
+    static isEqualBorderTokenValue(a: BorderTokenValue, b: BorderTokenValue): boolean;
+    static isEqualColorTokenValue(a: ColorTokenValue, b: ColorTokenValue): boolean;
+    static isEqualGradientsTokenValue(a: GradientTokenValue[], b: GradientTokenValue[]): boolean;
+    static isEqualGradientTokenValue(a: GradientTokenValue, b: GradientTokenValue): boolean;
+    static isEqualGradientStops(a: Array<GradientStopValue>, b: Array<GradientStopValue>): boolean;
+    static isEqualDimensionTokenValue(a: AnyDimensionTokenValue | undefined | null, b: AnyDimensionTokenValue | undefined | null): boolean;
+    static isEqualShadowsTokenValue(a: ShadowTokenValue[], b: ShadowTokenValue[]): boolean;
+    static isEqualShadowTokenValue(a: ShadowTokenValue, b: ShadowTokenValue): boolean;
+    static isEqualStringTokenValue(a: AnyStringTokenValue, b: AnyStringTokenValue): boolean;
+    static isEqualOptionTokenValue(a: AnyOptionTokenValue, b: AnyOptionTokenValue): boolean;
+    static isEqualTypographyTokenValue(a: TypographyTokenValue, b: TypographyTokenValue): boolean;
+}

package/build/sdk-typescript/src/model/tokens/SDKTokenValue.d.ts

@@ -0,0 +1,201 @@
+import { BlurType } from "../enums/SDKBlurType";
+import { BorderPosition } from "../enums/SDKBorderPosition";
+import { BorderStyle } from "../enums/SDKBorderStyle";
+import { GradientType } from "../enums/SDKGradientType";
+import { ShadowType } from "../enums/SDKShadowType";
+import { TokenType } from "../enums/SDKTokenType";
+import { LineHeightUnit, MsUnit, PxUnit, RawUnit, SizeUnit, Unit } from "../enums/SDKUnit";
+import { TokenOrigin } from "../support/SDKTokenOrigin";
+import { BlurToken } from "./SDKBlurToken";
+import { BorderToken } from "./SDKBorderToken";
+import { ColorToken } from "./SDKColorToken";
+import { AnyDimensionToken } from "./SDKDimensionToken";
+import { GradientToken } from "./SDKGradientToken";
+import { ShadowToken } from "./SDKShadowToken";
+import { AnyStringToken } from "./SDKStringToken";
+import { TextCaseToken } from "./SDKTextCaseToken";
+import { TextDecorationToken } from "./SDKTextDecorationToken";
+import { Token } from "./SDKToken";
+import { TypographyToken } from "./SDKTypographyToken";
+import { VisibilityToken } from "./SDKVisibilityToken";
+export type TokenValue = {
+    id: string;
+    name: string;
+    description: string;
+    tokenType: TokenType;
+    origin: TokenOrigin | null;
+};
+export type ColorTokenValue = {
+    color: ColorValue;
+    opacity: OpacityTokenValue;
+    referencedTokenId: string | null;
+};
+export type ColorValue = {
+    r: number;
+    g: number;
+    b: number;
+    referencedTokenId: string | null;
+};
+export type TypographyTokenValue = {
+    fontFamily: FontFamilyTokenValue;
+    fontWeight: FontWeightTokenValue;
+    fontSize: FontSizeTokenValue;
+    textDecoration: TextDecorationTokenValue;
+    textCase: TextCaseTokenValue;
+    letterSpacing: LetterSpacingTokenValue;
+    lineHeight: LineHeightTokenValue | null;
+    paragraphIndent: ParagraphSpacingTokenValue;
+    paragraphSpacing: ParagraphSpacingTokenValue;
+    referencedTokenId: string | null;
+};
+export type ShadowTokenValue = {
+    color: ColorTokenValue;
+    x: number;
+    y: number;
+    radius: number;
+    spread: number;
+    opacity?: OpacityTokenValue;
+    type: ShadowType;
+    referencedTokenId: string | null;
+};
+export type DimensionTokenValue = {
+    unit: Unit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type SizeTokenValue = {
+    unit: SizeUnit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type SpaceTokenValue = {
+    unit: SizeUnit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type OpacityTokenValue = {
+    unit: RawUnit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type FontSizeTokenValue = {
+    unit: SizeUnit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type LineHeightTokenValue = {
+    unit: LineHeightUnit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type LetterSpacingTokenValue = {
+    unit: SizeUnit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type ParagraphSpacingTokenValue = {
+    unit: SizeUnit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type BorderWidthTokenValue = {
+    unit: PxUnit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type RadiusTokenValue = {
+    unit: PxUnit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type DurationTokenValue = {
+    unit: MsUnit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type ZIndexTokenValue = {
+    unit: RawUnit;
+    measure: number;
+    referencedTokenId: string | null;
+};
+export type AnyDimensionTokenValue = DimensionTokenValue | SizeTokenValue | SpaceTokenValue | OpacityTokenValue | FontSizeTokenValue | LineHeightTokenValue | LetterSpacingTokenValue | ParagraphSpacingTokenValue | BorderWidthTokenValue | RadiusTokenValue | DurationTokenValue | ZIndexTokenValue;
+export type BorderTokenValue = {
+    color: ColorTokenValue;
+    width: BorderWidthTokenValue;
+    position: BorderPosition;
+    style: BorderStyle;
+    referencedTokenId: string | null;
+};
+export type GradientTokenValue = {
+    to: {
+        x: number;
+        y: number;
+    };
+    from: {
+        x: number;
+        y: number;
+    };
+    type: GradientType;
+    aspectRatio: number;
+    stops: Array<GradientStopValue>;
+    referencedTokenId: string | null;
+};
+export type GradientStopValue = {
+    position: number;
+    color: ColorTokenValue;
+};
+export type StringTokenValue = {
+    text: string;
+    referencedTokenId: string | null;
+};
+export type ProductCopyTokenValue = {
+    text: string;
+    referencedTokenId: string | null;
+};
+export type FontFamilyTokenValue = {
+    text: string;
+    referencedTokenId: string | null;
+};
+export type FontWeightTokenValue = {
+    text: string;
+    referencedTokenId: string | null;
+};
+export type AnyStringTokenValue = StringTokenValue | ProductCopyTokenValue | FontFamilyTokenValue | FontWeightTokenValue;
+export type TextCaseTokenValue = {
+    value: string;
+    options?: string[];
+    referencedTokenId: string | null;
+};
+export type TextDecorationTokenValue = {
+    value: string;
+    options?: string[];
+    referencedTokenId: string | null;
+};
+export type VisibilityTokenValue = {
+    value: string;
+    options?: string[];
+    referencedTokenId: string | null;
+};
+export type AnyOptionTokenValue = TextCaseTokenValue | TextDecorationTokenValue | VisibilityTokenValue;
+export type AnyOptionToken = TextCaseToken | TextDecorationToken | VisibilityToken;
+export type BlurTokenValue = {
+    type: BlurType;
+    radius: DimensionTokenValue;
+    referencedTokenId: string | null;
+};
+export type AnyTokenValue = ColorTokenValue | AnyStringTokenValue | TypographyTokenValue | ShadowTokenValue[] | AnyDimensionTokenValue | BorderTokenValue | GradientTokenValue[] | BlurTokenValue | AnyOptionTokenValue;
+export type AnyToken = ColorToken | AnyStringToken | TypographyToken | ShadowToken | AnyDimensionToken | BorderToken | GradientToken | BlurToken | AnyOptionToken;
+export type AnySingleLayerToken = Exclude<AnyToken, ShadowToken | GradientToken>;
+export type AnyMultiLayerToken = ShadowToken | GradientToken;
+export type AnyMultiLayerTokenValue = ShadowTokenValue | GradientTokenValue;
+export type AnyPlainTokenValue = Exclude<AnyTokenValue, ShadowTokenValue[] | GradientTokenValue[]> | ShadowTokenValue | GradientTokenValue;
+export type RawValue<T extends {
+    referencedTokenId: string;
+}> = Omit<T, "referencedTokenId">;
+export declare const getReferencedTokens: (token: AnyToken, allTokens: Map<string, Token>) => (Token | undefined)[];
+export declare const getSingleReferencedTokenId: (token: AnyToken, allTokens: Map<string, Token>) => string | undefined;
+export declare const checkSingleReferencedTokenById: (token: AnyToken, candidateId: string, allTokens: Map<string, Token>) => boolean | "";
+export declare const replaceReferencedTokenIds: (token: AnyToken, currentId: string, newId: string, allTokens: Map<string, Token>) => void;
+export declare const replaceReferencedToken: (token: Token, existingToken: AnyToken, newToken: AnyToken) => void;
+export declare const replaceReferencedTokenByIds: (token: Token, existingTokenId: string, newTokenId: string) => void;
+export declare const replaceOriginReferencePersistentIdByIds: (token: Token, existingTokenId: string, newTokenId: string) => void;

package/build/sdk-typescript/src/model/tokens/SDKTypographyToken.d.ts

@@ -0,0 +1,20 @@
+import { DTTokenReferenceResolver } from "../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver";
+import { ElementProperty } from "../elements/SDKElementProperty";
+import { ElementPropertyValue } from "../elements/values/SDKElementPropertyValue";
+import { TokenType } from "../enums/SDKTokenType";
+import { TokenRemoteModel, TypographyTokenRemoteModel } from "./remote/SDKRemoteTokenModel";
+import { TypographyTokenRemoteValue } from "./remote/SDKRemoteTokenValue";
+import { Token } from "./SDKToken";
+import { TypographyTokenValue } from "./SDKTokenValue";
+export declare class TypographyToken extends Token {
+    value: TypographyTokenValue;
+    tokenType: TokenType.typography;
+    constructor(versionId: string, baseToken: TokenRemoteModel, value: TypographyTokenValue, alias: TypographyToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(versionId: string, brandId: string, name: string, description: string, value: object, alias: TypographyToken | null, referenceResolver: DTTokenReferenceResolver, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): TypographyToken;
+    static typographyValueFromDefinition(definition: any, referenceResolver: DTTokenReferenceResolver): TypographyTokenValue;
+    toWriteObject(): TypographyTokenRemoteModel;
+    static valueToWriteObject(value: TypographyTokenValue): {
+        aliasTo: string | undefined;
+        value: TypographyTokenRemoteValue;
+    };
+}

package/build/sdk-typescript/src/model/tokens/SDKVisibilityToken.d.ts

@@ -0,0 +1,18 @@
+import { ElementProperty } from "../elements/SDKElementProperty";
+import { ElementPropertyValue } from "../elements/values/SDKElementPropertyValue";
+import { TokenType } from "../enums/SDKTokenType";
+import { TextCaseTokenRemoteModel, TokenRemoteModel } from "./remote/SDKRemoteTokenModel";
+import { VisibilityTokenRemoteValue } from "./remote/SDKRemoteTokenValue";
+import { Token } from "./SDKToken";
+import { VisibilityTokenValue } from "./SDKTokenValue";
+export declare class VisibilityToken extends Token {
+    value: VisibilityTokenValue;
+    tokenType: TokenType.visibility;
+    constructor(versionId: string, baseToken: TokenRemoteModel, value: VisibilityTokenValue, alias: VisibilityToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(versionId: string, brandId: string, name: string, description: string, value: string, alias: VisibilityToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): VisibilityToken;
+    toWriteObject(): TextCaseTokenRemoteModel;
+    static valueToWriteObject(value: VisibilityTokenValue): {
+        aliasTo: string | undefined;
+        value: VisibilityTokenRemoteValue;
+    };
+}