@supernova-studio/supernova-sdk-beta 1.6.10

package/build/sdk-typescript/src/model/groups/SDKDesignComponentGroup.d.ts

@@ -0,0 +1,33 @@
+export interface DesignComponentGroupRemoteModel {
+    id: string;
+    designSystemVersionId: string;
+    persistentId: string;
+    brandId: string;
+    isRoot: boolean;
+    meta: {
+        name: string;
+        description: string;
+    };
+    childrenIds: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+export declare class DesignComponentGroup {
+    id: string;
+    brandId: string;
+    name: string;
+    description: string;
+    path: Array<string>;
+    subgroups: Array<DesignComponentGroup>;
+    isRoot: boolean;
+    childrenIds: Array<string>;
+    componentIds: Array<string>;
+    parent: DesignComponentGroup | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    constructor(model: DesignComponentGroupRemoteModel);
+    addChild(group: DesignComponentGroup): void;
+    addChildren(groups: Array<DesignComponentGroup>): void;
+    setPath(segments: Array<string>): void;
+    setParent(parent: DesignComponentGroup | null): void;
+}

package/build/sdk-typescript/src/model/groups/SDKTokenGroup.d.ts

@@ -0,0 +1,42 @@
+import { TokenType } from '../enums/SDKTokenType';
+export interface TokenGroupRemoteModel {
+    id: string;
+    brandId: string;
+    tokenType: TokenType;
+    designSystemVersionId: string;
+    persistentId: string;
+    isRoot: boolean;
+    meta: {
+        name: string;
+        description: string;
+    };
+    childrenIds: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+export declare class TokenGroup {
+    id: string;
+    versionedId: string;
+    brandId: string;
+    designSystemVersionId: string;
+    name: string;
+    description: string;
+    path: Array<string>;
+    subgroups: Array<TokenGroup>;
+    tokenType: TokenType;
+    isRoot: boolean;
+    childrenIds: Array<string>;
+    tokenIds: Array<string>;
+    parent: TokenGroup | null;
+    sortOrder: number;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    constructor(model: TokenGroupRemoteModel);
+    addChild(group: TokenGroup): void;
+    addChildren(groups: Array<TokenGroup>): void;
+    setPath(segments: Array<string>): void;
+    setParent(parent: TokenGroup | null): void;
+    setSortOrder(order: number): void;
+    toWriteObject(): TokenGroupRemoteModel;
+    toMutatedObject(childrenIds: Array<string>): TokenGroup;
+}

package/build/sdk-typescript/src/model/support/SDKDesignComponentOrigin.d.ts

@@ -0,0 +1,23 @@
+import { SourceType } from '../enums/SDKSourceType';
+import { Source } from './SDKSource';
+export interface DesignComponentOriginModel {
+    id: string;
+    sourceId: string;
+    nodeId: string;
+    name?: string;
+    width?: number;
+    height?: number;
+}
+export declare class DesignComponentOrigin {
+    sourceType: SourceType;
+    sourceId: string | null;
+    fileId: string | null;
+    fileName: string | null;
+    id: string | null;
+    nodeId: string | null;
+    name: string | null;
+    width: number | null;
+    height: number | null;
+    constructor(model: DesignComponentOriginModel, sources: Array<Source>);
+    get remoteDesignComponentUrl(): string | undefined;
+}

package/build/sdk-typescript/src/model/support/SDKFrameOrigin.d.ts

@@ -0,0 +1,25 @@
+export interface FrameOriginModel {
+    title?: string;
+    previewUrl?: string;
+    referenceId?: string;
+    sourceFileName?: string;
+    valid?: boolean;
+    assetId?: string;
+    assetScale?: string;
+    width?: number;
+    height?: number;
+}
+export declare class FrameOrigin {
+    sourceFileName: string | null;
+    sourceFrameId: string | null;
+    sourceId: string | null;
+    title: string | null;
+    previewUrl: string | null;
+    referenceId: string | null;
+    valid: boolean | null;
+    assetId: string | null;
+    assetScale: string | null;
+    width: number | null;
+    height: number | null;
+    constructor(model: FrameOriginModel, sourceId: string | null, sourceFrameId: string | null);
+}

package/build/sdk-typescript/src/model/support/SDKSize.d.ts

@@ -0,0 +1,9 @@
+export interface SizeModel {
+    width?: number;
+    height?: number;
+}
+export declare class Size {
+    width: number | null;
+    height: number | null;
+    constructor(model: SizeModel | null);
+}

package/build/sdk-typescript/src/model/support/SDKSource.d.ts

@@ -0,0 +1,102 @@
+import { SourceType } from '../enums/SDKSourceType';
+export interface SourceRemoteModel {
+    type: SourceType;
+    id: string;
+    fileName?: string;
+    linkType: 'Design' | 'Frames';
+    brandId?: string;
+    plugin?: {
+        fileId: string;
+        lastImportedAt?: string;
+    };
+    cloud?: {
+        fileId: string;
+        autoImportMode: 'Never' | 'Hourly';
+        fileThumbnailUrl?: string;
+        lastUpdatesCheckedAt?: string;
+        lastImportedVersion?: {
+            id: string;
+            created_at: string;
+            label?: string;
+            description: string;
+        };
+        lastImportedAt?: string;
+        lastImportResult?: {
+            sourceId: string;
+            brandId: string;
+            tokensCreated: number;
+            tokensUpdated: number;
+            tokensDeleted: number;
+            componentsCreated: number;
+            componentsUpdated: number;
+            componentsDeleted: number;
+            componentAssetsCreated: number;
+            componentAssetsUpdated: number;
+            componentAssetsDeleted: number;
+            isFailed: boolean;
+            versionId: string;
+            fileSize?: number;
+        };
+        lastImportFramesResult?: {
+            sourceId: string;
+            isFailed: string;
+            error?: string;
+            assetsInFile?: {
+                frames: number;
+                components: number;
+            };
+            invalidReferencesCount?: number;
+        };
+        ownerId: string;
+        ownerUserName: string;
+        state: string;
+    };
+}
+export declare class Source {
+    type: SourceType;
+    id: string;
+    fileName: string | null;
+    fileId: string | null;
+    autoImportMode: 'Never' | 'Hourly' | null;
+    fileThumbnailUrl: string | null;
+    lastUpdatesCheckedAt: string | null;
+    lastImportedVersion: {
+        id: string;
+        created_at: string;
+        label: string | null;
+        description: string;
+    } | null;
+    lastImportedAt: string | null;
+    lastImportResult: {
+        sourceId: string;
+        brandId: string;
+        tokensCreated: number;
+        tokensUpdated: number;
+        tokensDeleted: number;
+        componentsCreated: number;
+        componentsUpdated: number;
+        componentsDeleted: number;
+        componentAssetsCreated: number;
+        componentAssetsUpdated: number;
+        componentAssetsDeleted: number;
+        isFailed: boolean;
+        versionId: string;
+        fileSize: number | null;
+    } | null;
+    lastImportFramesResult: {
+        sourceId: string;
+        isFailed: string;
+        error: string | null;
+        assetsInFile: {
+            frames: number;
+            components: number;
+        } | null;
+        invalidReferencesCount: number | null;
+    } | null;
+    ownerId: string | null;
+    ownerUserName: string | null;
+    state: string | null;
+    linkType: 'Design' | 'Frames';
+    brandId: string | null;
+    constructor(model: SourceRemoteModel);
+}

package/build/sdk-typescript/src/model/support/SDKTokenOrigin.d.ts

@@ -0,0 +1,11 @@
+export interface TokenOriginModel {
+    id?: string;
+    name?: string;
+    sourceId?: string;
+}
+export declare class TokenOrigin {
+    id: string | null;
+    name: string | null;
+    sourceId: string | null;
+    constructor(model: TokenOriginModel);
+}

package/build/sdk-typescript/src/model/support/SDKWorkspaceNPMRegistry.d.ts

@@ -0,0 +1,13 @@
+export interface WorkspaceNPMRegistryModel {
+    enabledScopes: Array<string>;
+    limitToScopes: boolean;
+    registryUrl: string;
+    proxyUrl: string;
+}
+export declare class WorkspaceNPMRegistry {
+    enabledScopes: Array<string>;
+    limitToScopes: boolean;
+    registryUrl: string;
+    proxyUrl: string;
+    constructor(model: WorkspaceNPMRegistryModel);
+}

package/build/sdk-typescript/src/model/themes/SDKThemeUtilities.d.ts

@@ -0,0 +1,6 @@
+import { Token, DesignSystemVersion, TokenOrigin } from '../..';
+import { AnyToken } from '../tokens/SDKTokenValue';
+export declare class ThemeUtilities {
+    /** Creates duplicate of the token */
+    static replicateTokenAsThemePrefabWithoutValue(token: Token, themeId: string, origin: TokenOrigin | null, version: DesignSystemVersion): AnyToken;
+}

package/build/sdk-typescript/src/model/themes/SDKTokenTheme.d.ts

@@ -0,0 +1,63 @@
+import { DesignSystemVersion, Token, TokenType } from '../..';
+import { AnyTokenValue } from '../tokens/SDKTokenValue';
+import { TokenThemeOverrideRemoteModel } from './SDKTokenThemeOverride';
+export interface TokenThemeRemoteModel {
+    meta: {
+        name: string;
+        description: string;
+    };
+    id: string;
+    persistentId: string;
+    designSystemVersionId: string;
+    brandId: string;
+    codeName: string;
+    createdAt?: string;
+    updatedAt?: string;
+    overrides: Array<TokenThemeOverrideRemoteModel>;
+}
+export declare class TokenTheme {
+    id: string;
+    versionedId: string;
+    brandId: string;
+    designSystemVersionId: string;
+    name: string;
+    description: string;
+    codeName: string;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    overriddenTokens: Array<Token>;
+    constructor(model: TokenThemeRemoteModel, dsVersion: DesignSystemVersion);
+    addOverride(override: Token): void;
+    addOverrides(overrides: Array<Token>): void;
+    toWriteObject(): TokenThemeRemoteModel;
+    private tokensToOverrides;
+    toWriteOverrideObject(token: Token): TokenThemeOverrideRemoteModel;
+    valueToWriteObject(value: AnyTokenValue, type: TokenType): {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BlurTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BorderTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: string;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").FontTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").GradientTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").MeasureTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").RadiusTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").ShadowTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").TypographyTokenRemoteValue;
+    };
+}

package/build/sdk-typescript/src/model/themes/SDKTokenThemeOverride.d.ts

@@ -0,0 +1,49 @@
+import { TokenType, TokenOrigin } from '../..';
+import { BlurTokenRemoteData, BorderTokenRemoteData, ColorTokenRemoteData, FontTokenRemoteData, GenericTokenRemoteData, GradientTokenRemoteData, MeasureTokenRemoteData, RadiusTokenRemoteData, ShadowTokenRemoteData, TextTokenRemoteData, TypographyTokenRemoteData } from '../tokens/remote/SDKRemoteTokenData';
+import { AnyTokenValue } from '../tokens/SDKTokenValue';
+export interface TokenThemeOverrideRemoteModel {
+    data: ColorTokenRemoteData | TextTokenRemoteData | GenericTokenRemoteData | TypographyTokenRemoteData | RadiusTokenRemoteData | ShadowTokenRemoteData | MeasureTokenRemoteData | FontTokenRemoteData | BorderTokenRemoteData | GradientTokenRemoteData | BlurTokenRemoteData;
+    tokenPersistentId: string;
+    type: TokenType;
+    origin: TokenOrigin | null;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export declare class TokenThemeOverride {
+    value: AnyTokenValue;
+    tokenId: string;
+    type: TokenType;
+    origin: TokenOrigin | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    constructor(model: TokenThemeOverrideRemoteModel, value: AnyTokenValue);
+    toWriteObject(): TokenThemeOverrideRemoteModel;
+    valueToWriteObject(value: AnyTokenValue, type: TokenType): {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BlurTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BorderTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: string;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").FontTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").GradientTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").MeasureTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").RadiusTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").ShadowTokenRemoteValue;
+    } | {
+        aliasTo: string;
+        value: import("../tokens/remote/SDKRemoteTokenValue").TypographyTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,18 @@
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { ElementProperty } from '../elements/SDKElementProperty';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+import { BlurTokenRemoteModel, TokenRemoteModel } from './remote/SDKRemoteTokenModel';
+import { BlurTokenRemoteValue } from './remote/SDKRemoteTokenValue';
+import { Token } from './SDKToken';
+import { BlurTokenValue } from './SDKTokenValue';
+export declare class BlurToken extends Token {
+    value: BlurTokenValue;
+    blurLayers: Array<BlurToken>;
+    isVirtual: boolean;
+    constructor(version: DesignSystemVersion, baseToken: TokenRemoteModel, value: BlurTokenValue, alias: BlurToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    toWriteObject(): BlurTokenRemoteModel;
+    static valueToWriteObject(value: BlurTokenValue): {
+        aliasTo: string | undefined;
+        value: BlurTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,19 @@
+import { Brand, ElementProperty } from '../..';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { DTTokenReferenceResolver } from '../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+import { BorderTokenRemoteModel, TokenRemoteModel } from './remote/SDKRemoteTokenModel';
+import { BorderTokenRemoteValue } from './remote/SDKRemoteTokenValue';
+import { Token } from './SDKToken';
+import { BorderTokenValue } from './SDKTokenValue';
+export declare class BorderToken extends Token {
+    value: BorderTokenValue;
+    constructor(version: DesignSystemVersion, baseToken: TokenRemoteModel, value: BorderTokenValue, alias: BorderToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(version: DesignSystemVersion, brand: Brand, name: string, description: string, value: object, alias: BorderToken | null, referenceResolver: DTTokenReferenceResolver, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): BorderToken;
+    static borderValueFromDefinition(definition: object, referenceResolver: DTTokenReferenceResolver): BorderTokenValue;
+    toWriteObject(): BorderTokenRemoteModel;
+    static valueToWriteObject(value: BorderTokenValue): {
+        aliasTo: string | undefined;
+        value: BorderTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,22 @@
+import { Brand, ElementProperty } from '../..';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { ColorTokenRemoteModel, TokenRemoteModel } from './remote/SDKRemoteTokenModel';
+import { ColorTokenRemoteValue } from './remote/SDKRemoteTokenValue';
+import { Token } from './SDKToken';
+import { ColorTokenValue } from './SDKTokenValue';
+import { DTTokenReferenceResolver } from '../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+export declare class ColorToken extends Token {
+    value: ColorTokenValue;
+    constructor(version: DesignSystemVersion, baseToken: TokenRemoteModel, value: ColorTokenValue, alias: ColorToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(version: DesignSystemVersion, brand: Brand, name: string, description: string, value: string, alias: ColorToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): ColorToken;
+    static colorValueFromDefinition(definition: string): ColorTokenValue;
+    static normalizeColor(color: string): string | null;
+    static normalizeOpacity(value: string): number;
+    static colorValueFromDefinitionOrReference(definition: any, referenceResolver: DTTokenReferenceResolver): ColorTokenValue | undefined;
+    toWriteObject(): ColorTokenRemoteModel;
+    static valueToWriteObject(value: ColorTokenValue): {
+        aliasTo: string | undefined;
+        value: ColorTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,16 @@
+import { ElementProperty } from '../..';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+import { FontTokenRemoteModel, TokenRemoteModel } from './remote/SDKRemoteTokenModel';
+import { FontTokenRemoteValue } from './remote/SDKRemoteTokenValue';
+import { Token } from './SDKToken';
+import { FontTokenValue } from './SDKTokenValue';
+export declare class FontToken extends Token {
+    value: FontTokenValue;
+    constructor(version: DesignSystemVersion, baseToken: TokenRemoteModel, value: FontTokenValue, alias: FontToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    toWriteObject(): FontTokenRemoteModel;
+    static valueToWriteObject(value: FontTokenValue): {
+        aliasTo: string | undefined;
+        value: FontTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,18 @@
+import { Brand, ElementProperty } from '../..';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+import { GenericTokenRemoteModel, TokenRemoteModel } from './remote/SDKRemoteTokenModel';
+import { TextTokenRemoteValue } from './remote/SDKRemoteTokenValue';
+import { Token } from './SDKToken';
+import { GenericTokenValue } from './SDKTokenValue';
+export declare class GenericToken extends Token {
+    value: GenericTokenValue;
+    constructor(version: DesignSystemVersion, baseToken: TokenRemoteModel, value: GenericTokenValue, alias: GenericToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(version: DesignSystemVersion, brand: Brand, name: string, description: string, value: string, alias: GenericToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): GenericToken;
+    static measureValueFromDefinition(definition: string): GenericTokenValue;
+    toWriteObject(): GenericTokenRemoteModel;
+    static valueToWriteObject(value: GenericTokenValue): {
+        aliasTo: string | undefined;
+        value: TextTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,18 @@
+import { ElementProperty } from '../..';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+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;
+    constructor(version: DesignSystemVersion, baseToken: TokenRemoteModel, value: GradientTokenValue, alias: GradientToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    toWriteObject(): GradientTokenRemoteModel;
+    static valueToWriteObject(value: GradientTokenValue): {
+        aliasTo: string | undefined;
+        value: GradientTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,26 @@
+import { Brand, ElementProperty } from '../..';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { DTTokenReferenceResolver } from '../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+import { Unit } from '../enums/SDKUnit';
+import { MeasureTokenRemoteModel, TokenRemoteModel } from './remote/SDKRemoteTokenModel';
+import { MeasureTokenRemoteValue } from './remote/SDKRemoteTokenValue';
+import { Token } from './SDKToken';
+import { MeasureTokenValue } from './SDKTokenValue';
+export declare class MeasureToken extends Token {
+    value: MeasureTokenValue;
+    constructor(version: DesignSystemVersion, baseToken: TokenRemoteModel, value: MeasureTokenValue, alias: MeasureToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(version: DesignSystemVersion, brand: Brand, name: string, description: string, value: string | number, alias: MeasureToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): MeasureToken;
+    static measureValueFromDefinition(definition: string | number): MeasureTokenValue;
+    static parseMeasure(definition: string): {
+        measure: number;
+        unit: Unit;
+    };
+    static measureValueFromDefinitionOrReference(definition: any, referenceResolver: DTTokenReferenceResolver): MeasureTokenValue;
+    toWriteObject(): MeasureTokenRemoteModel;
+    static valueToWriteObject(value: MeasureTokenValue): {
+        aliasTo: string | undefined;
+        value: MeasureTokenRemoteValue;
+    };
+    static valueToInternalWriteObject(value: MeasureTokenValue | null): MeasureTokenValue | null;
+}

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

@@ -0,0 +1,18 @@
+import { Brand, ElementProperty } from '../..';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+import { RadiusTokenRemoteModel, TokenRemoteModel } from './remote/SDKRemoteTokenModel';
+import { RadiusTokenRemoteValue } from './remote/SDKRemoteTokenValue';
+import { Token } from './SDKToken';
+import { RadiusTokenValue } from './SDKTokenValue';
+export declare class RadiusToken extends Token {
+    value: RadiusTokenValue;
+    constructor(version: DesignSystemVersion, baseToken: TokenRemoteModel, value: RadiusTokenValue, alias: RadiusToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(version: DesignSystemVersion, brand: Brand, name: string, description: string, value: string, alias: RadiusToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): RadiusToken;
+    static radiusValueFromDefinition(definition: string | number): RadiusTokenValue;
+    toWriteObject(): RadiusTokenRemoteModel;
+    static valueToWriteObject(value: RadiusTokenValue): {
+        aliasTo: string | undefined;
+        value: RadiusTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,21 @@
+import { Brand, ElementProperty } from '../..';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { DTTokenReferenceResolver } from '../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+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: ShadowTokenValue;
+    shadowLayers: Array<ShadowToken>;
+    isVirtual: boolean;
+    constructor(version: DesignSystemVersion, baseToken: TokenRemoteModel, value: ShadowTokenValue, alias: ShadowToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(version: DesignSystemVersion, brand: Brand, 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;
+    toWriteObject(): ShadowTokenRemoteModel;
+    static valueToWriteObject(value: ShadowTokenValue): {
+        aliasTo: string | undefined;
+        value: ShadowTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,16 @@
+import { ElementProperty } from '../..';
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+import { TextTokenRemoteModel, TokenRemoteModel } from './remote/SDKRemoteTokenModel';
+import { TextTokenRemoteValue } from './remote/SDKRemoteTokenValue';
+import { Token } from './SDKToken';
+import { TextTokenValue } from './SDKTokenValue';
+export declare class TextToken extends Token {
+    value: TextTokenValue;
+    constructor(version: DesignSystemVersion, baseToken: TokenRemoteModel, value: TextTokenValue, alias: TextToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    toWriteObject(): TextTokenRemoteModel;
+    static valueToWriteObject(value: TextTokenValue): {
+        aliasTo: string | undefined;
+        value: TextTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,30 @@
+import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
+import { ElementProperty } from '../elements/SDKElementProperty';
+import { ElementPropertyValue } from '../elements/values/SDKElementPropertyValue';
+import { TokenType } from '../enums/SDKTokenType';
+import { TokenGroup } from '../groups/SDKTokenGroup';
+import { TokenOrigin } from '../support/SDKTokenOrigin';
+import { TokenRemoteModel } from './remote/SDKRemoteTokenModel';
+import { TokenValue } from './SDKTokenValue';
+export declare class Token implements TokenValue {
+    id: string;
+    versionedId: string;
+    brandId: string;
+    themeId: string | null;
+    designSystemVersionId: string;
+    name: string;
+    description: string;
+    tokenType: TokenType;
+    origin: TokenOrigin | null;
+    parent: TokenGroup | null;
+    sortOrder: number;
+    properties: Array<ElementProperty>;
+    propertyValues: object;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    constructor(model: TokenRemoteModel, dsVersion: DesignSystemVersion, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>, empty?: boolean);
+    setParent(parent: TokenGroup | 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 '../..';
+import { AnyTokenValue, BlurTokenValue, BorderTokenValue, ColorTokenValue, FontTokenValue, GenericTokenValue, GradientTokenValue, MeasureTokenValue, RadiusTokenValue, ShadowTokenValue, TextTokenValue, TypographyTokenValue, GradientStopValue } from './SDKTokenValue';
+export declare class TokenComparator {
+    static isEqualTokenValue(a: Token, b: Token): boolean;
+    static referencesSameToken(a: AnyTokenValue, b: AnyTokenValue): boolean;
+    static anyIsReference(a: AnyTokenValue, b: AnyTokenValue): boolean;
+    static isUndefinedValue(a: AnyTokenValue, b: AnyTokenValue): boolean;
+    static isEqualBlurTokenValue(a: BlurTokenValue, b: BlurTokenValue): boolean;
+    static isEqualBorderTokenValue(a: BorderTokenValue, b: BorderTokenValue): boolean;
+    static isEqualColorTokenValue(a: ColorTokenValue, b: ColorTokenValue): boolean;
+    static isEqualFontTokenValue(a: FontTokenValue, b: FontTokenValue): boolean;
+    static isEqualGenericTokenValue(a: GenericTokenValue, b: GenericTokenValue): boolean;
+    static isEqualGradientTokenValue(a: GradientTokenValue, b: GradientTokenValue): boolean;
+    static isEqualGradientStops(a: Array<GradientStopValue>, b: Array<GradientStopValue>): boolean;
+    static isEqualMeasureTokenValue(a: MeasureTokenValue, b: MeasureTokenValue): boolean;
+    static isEqualRadiusTokenValue(a: RadiusTokenValue, b: RadiusTokenValue): boolean;
+    static isEqualShadowTokenValue(a: ShadowTokenValue, b: ShadowTokenValue): boolean;
+    static isEqualTextTokenValue(a: TextTokenValue, b: TextTokenValue): boolean;
+    static isEqualTypographyTokenValue(a: TypographyTokenValue, b: TypographyTokenValue): boolean;
+}