@supernova-studio/supernova-sdk-beta 0.7.17

package/build/sdk-typescript/src/model/jobs/SDKImportJob.d.ts

@@ -0,0 +1,34 @@
+import { ImportJobOperation } from "../enums/SDKImportJobOperation";
+import { ImportJobState } from "../enums/SDKImportJobState";
+export type ImportJobRemoteModel = {
+    id: string;
+    designSystemId: string;
+    designSystemVersionId: string;
+    createdAt?: string;
+    stateChangedAt?: string;
+    state: ImportJobState;
+    error?: string;
+    operation: ImportJobOperation;
+    sourceIds: Array<string>;
+};
+export declare class ImportJob {
+    /** Unique identifier of the job */
+    id: string;
+    /** Unique identifier of the design system this job lives in */
+    designSystemId: string;
+    /** Unique identifier of the design system version this job lives in */
+    designSystemVersionId: string;
+    /** Job creation date */
+    createdAt: Date | null;
+    /** Date of the last change of the job status */
+    stateChangedAt: Date | null;
+    /** Job state - Queued, InProgress, Failed or Success */
+    state: ImportJobState;
+    /** Reason for failure of this import job. Will only be present if `state === failed` */
+    error: string | null;
+    /** Job operation - Check or Import */
+    operation: ImportJobOperation;
+    /** All sources participating in this import job */
+    sourceIds: Array<string>;
+    constructor(model: ImportJobRemoteModel);
+}

package/build/sdk-typescript/src/model/membership/SDKMembership.d.ts

@@ -0,0 +1,16 @@
+import { UserRole } from "../enums/SDKUserRole";
+import { Workspace, WorkspaceRemoteModel } from "../workspaces/SDKWorkspace";
+export type MembershipRemoteModel = {
+    workspace: WorkspaceRemoteModel;
+    role: UserRole;
+    effectiveRole: UserRole;
+};
+export declare class Membership {
+    /** Workspace of this membership. */
+    workspace: Workspace;
+    /** Selected role of the user. */
+    role: UserRole;
+    /** Actual role of the user. */
+    effectiveRole: UserRole;
+    constructor(model: MembershipRemoteModel);
+}

package/build/sdk-typescript/src/model/resources/SDKResource.d.ts

@@ -0,0 +1,26 @@
+export declare enum ResourceType {
+    asset = "Asset",
+    font = "Font"
+}
+export type ResourceModel = {
+    id: string;
+    persistentId: string;
+    url: string;
+    originalName?: string;
+    scope: "DesignSystem" | "Documentation";
+};
+export declare class Resource {
+    /** Unique identifier of the resource */
+    id: string;
+    /** Unique identifier of the resource in the version */
+    idInVersion: string;
+    /** URL of the resource */
+    url: string;
+    /** Original filename of the resource */
+    originalName: string | null;
+    /** Scope of the resource */
+    scope: "DesignSystem" | "Documentation";
+    /** Type of the resource */
+    type: ResourceType;
+    constructor(model: ResourceModel);
+}

package/build/sdk-typescript/src/model/resources/SDKResourceAsset.d.ts

@@ -0,0 +1,6 @@
+import { Resource, ResourceModel, ResourceType } from "./SDKResource";
+export type ResourceAssetModel = ResourceModel;
+export declare class ResourceAsset extends Resource {
+    type: ResourceType;
+    constructor(model: ResourceAssetModel);
+}

package/build/sdk-typescript/src/model/resources/SDKResourceFont.d.ts

@@ -0,0 +1,25 @@
+import { Resource, ResourceModel, ResourceType } from "./SDKResource";
+export type ResourceFontModel = ResourceModel & {
+    fontProperties?: Array<{
+        family?: string;
+        subfamily?: string;
+        weight?: number;
+        isItalic?: boolean;
+        isOutlined?: boolean;
+        isStrikeout?: boolean;
+        isUnderscore?: boolean;
+    }>;
+};
+export declare class ResourceFont extends Resource {
+    type: ResourceType;
+    fontProperties: {
+        family: string | null;
+        subfamily: string | null;
+        weight: number | null;
+        isItalic: boolean | null;
+        isOutlined: boolean | null;
+        isStrikeout: boolean | null;
+        isUnderscore: boolean | null;
+    } | null;
+    constructor(model: ResourceFontModel);
+}

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

@@ -0,0 +1,21 @@
+import { CustomDomainErrorCode } from "../enums/SDKCustomDomainErrorCode";
+import { CustomDomainState } from "../enums/SDKCustomDomainState";
+export type CustomDomainRemoteModel = {
+    id: string;
+    designSystemId: string;
+    supernovaDomain: string;
+    customerDomain: string;
+    state: CustomDomainState;
+    error: string | null;
+    errorCode: CustomDomainErrorCode;
+};
+export declare class CustomDomain {
+    id: string;
+    designSystemId: string;
+    supernovaDomain: string;
+    customerDomain: string;
+    state: CustomDomainState;
+    error: string | null;
+    errorCode: CustomDomainErrorCode | null;
+    constructor(model: CustomDomainRemoteModel);
+}

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

@@ -0,0 +1,23 @@
+import { SourceType } from "../enums/SDKSourceType";
+import { Source } from "./SDKSource";
+export type 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/SDKFigmaFrame.d.ts

@@ -0,0 +1,22 @@
+export declare enum FrameType {
+    DOCUMENT = "DOCUMENT",
+    CANVAS = "CANVAS",
+    COMPONENT_SET = "COMPONENT_SET",
+    COMPONENT_VARIANT = "COMPONENT_VARIANT",
+    COMPONENT = "COMPONENT",
+    SECTION = "SECTION",
+    FRAME = "FRAME"
+}
+export type FigmaFrameModel = {
+    id: string;
+    name: string;
+    type: FrameType;
+    children: Array<FigmaFrameModel>;
+};
+export declare class FigmaFrame {
+    id: string;
+    name: string;
+    type: FrameType;
+    children: Array<FigmaFrame>;
+    constructor(model: FigmaFrameModel);
+}

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

@@ -0,0 +1,27 @@
+export type FigmaStructureModel = {
+    assetsInFile: {
+        componentSets: number;
+        components: number;
+        frames: number;
+    };
+    designSystemVersionId: string;
+    id: string;
+    origin: {
+        sourceId: string;
+    };
+    persistentId: string;
+};
+export declare class FigmaStructure {
+    assetsInFile: {
+        componentSets: number;
+        components: number;
+        frames: number;
+    };
+    designSystemVersionId: string;
+    id: string;
+    origin: {
+        sourceId: string;
+    };
+    persistentId: string;
+    constructor(model: FigmaStructureModel);
+}

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

@@ -0,0 +1,30 @@
+import { FigmaFrameModel } from "./SDKFigmaFrame";
+export type FigmaStructureDetailModel = {
+    assetsInFile: {
+        componentSets: number;
+        components: number;
+        frames: number;
+    };
+    designSystemVersionId: string;
+    id: string;
+    origin: {
+        sourceId: string;
+    };
+    persistentId: string;
+    rootNode: FigmaFrameModel;
+};
+export declare class FigmaStructureDetail {
+    assetsInFile: {
+        componentSets: number;
+        components: number;
+        frames: number;
+    };
+    designSystemVersionId: string;
+    id: string;
+    origin: {
+        sourceId: string;
+    };
+    persistentId: string;
+    rootNode: FigmaFrameModel;
+    constructor(model: FigmaStructureDetailModel);
+}

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

@@ -0,0 +1,25 @@
+export type 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/SDKLogger.d.ts

@@ -0,0 +1,4 @@
+export declare class Logger {
+    logs: string[];
+    log(message: string): void;
+}

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

@@ -0,0 +1,9 @@
+export type 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,150 @@
+import { ImportWarningType } from "../enums/SDKCloudWarningType";
+import { SourceType } from "../enums/SDKSourceType";
+declare enum SourceRemoteType {
+    figma = "Figma",
+    tokenStudio = "TokenStudio",
+    figmaVariablesPlugin = "FigmaVariablesPlugin",
+    upload = "Upload"
+}
+export type SourceRemoteModel = {
+    type: SourceRemoteType;
+    id: string;
+    fileName?: string;
+    brandId?: string;
+    plugin?: {
+        fileId: string;
+        lastImportedAt?: string;
+    };
+    cloud?: SourceRemoteModelCloud;
+    tokenStudio?: SourceRemoteModelTokensStudio;
+    figmaVariablesPlugin?: SourceRemoteModelFigmaVariablesPlugin;
+    scope: SourceScope;
+};
+export type SourceScope = {
+    tokens: boolean;
+    components: boolean;
+    assets: boolean;
+    documentationFrames: boolean;
+};
+export type SourceRemoteModelCloud = {
+    fileId?: string;
+    autoImportMode: "Never" | "Hourly";
+    fileThumbnailUrl?: string;
+    lastUpdatesCheckedAt?: string;
+    lastImportedVersion?: {
+        id: string;
+        /** Date of file creation in Figma */
+        created_at: string;
+        label?: string;
+        description: string;
+    };
+    /** This indicates last import try attempt, either failed or succeed  */
+    lastImportedAt?: string;
+    /** This is last successful import results, so if last import failed this won't change */
+    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;
+        warnings?: Array<SourceImportResultWarning>;
+        isFramesFailed: boolean;
+        assetsInFile?: {
+            frames: number;
+            components: number;
+        };
+        invalidReferencesCount?: number;
+    };
+    ownerId: string;
+    ownerUserName: string;
+    state: "Active" | "MissingIntegration" | "MissingFileAccess" | "MissingFileOwner";
+    stats: {
+        tokens: number;
+        components: number;
+        assets: number;
+        frames: number;
+    };
+};
+export type SourceImportResultWarning = {
+    warningType: ImportWarningType;
+    componentId: string;
+    componentName: string;
+    styleId: string;
+    styleName: string;
+    unsupportedStyleValueType: string;
+};
+export type SourceRemoteModelTokensStudio = {
+    connectionName: string;
+    lastImportedAt?: string;
+    settings?: {
+        dryRun?: boolean;
+        verbose?: boolean;
+        preciseCopy?: boolean;
+    };
+    lastImportedResults?: Array<{
+        mapping: {
+            tokensTheme?: string;
+            tokenSets?: string[];
+            supernovaBrand?: string;
+            supernovaTheme?: string;
+        };
+        tokensCreated: number;
+        tokensUpdated: number;
+        tokensDeleted: number;
+        isFailed: boolean;
+        error?: string;
+        themeId?: string;
+    }>;
+};
+export type SourceRemoteModelFigmaVariablesPlugin = {
+    fileId: string;
+    lastImportedAt?: string;
+    lastImportMetadata?: Record<string, any>;
+};
+export type SourceModelTokenStudio = Omit<SourceRemoteModelTokensStudio, "lastUpdatesCheckedAt" | "lastImportedAt"> & {
+    lastUpdatesCheckedAt?: Date;
+    lastImportedAt?: Date;
+};
+export type SourceModelCloud = Omit<SourceRemoteModelCloud, "lastUpdatesCheckedAt" | "lastImportedAt"> & {
+    lastUpdatesCheckedAt?: Date;
+    lastImportedAt?: Date;
+};
+export type SourceModelFigmaVariablesPlugin = Omit<SourceRemoteModelFigmaVariablesPlugin, "lastImportedAt"> & {
+    lastImportedAt?: Date;
+};
+export type SourceTransportModel = Pick<Source, "type" | "id" | "fileName" | "brandId" | "scope"> & {
+    cloud?: SourceRemoteModelCloud | null;
+};
+export declare class Source {
+    type: SourceType;
+    id: string;
+    fileName: string | null;
+    brandId: string | null;
+    cloud: SourceModelCloud | null;
+    tokenStudio?: SourceModelTokenStudio | null;
+    figmaVariablesPlugin?: SourceModelFigmaVariablesPlugin | null;
+    scope: SourceScope;
+    get lastImportedAt(): Date | null;
+    get hasError(): boolean;
+    get hasWarning(): boolean;
+    get isCloudAvailable(): boolean;
+    get isTokensStudioAvailable(): boolean;
+    get tokensStudioHasError(): boolean;
+    constructor(model: SourceRemoteModel);
+    /** Constructs representation that can be used to write full object to remote */
+    toRemote(): SourceRemoteModel;
+    /** Constructs representation that can be used to transport the instantiated object as JSON, for example for SSR <> Client use-cases. Reconstruct to class instance using `fromTransport` */
+    toTransport(): SourceTransportModel;
+    /** Reconstructs class from the transport model */
+    static fromTransport(model: SourceTransportModel): SourceRemoteModel;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { SourceType } from "../enums/SDKSourceType";
+export type TokenOriginModel = {
+    id?: string;
+    name?: string;
+    sourceId?: string;
+    sourceType?: SourceType;
+    referenceOriginId?: string;
+    referencePersistentId?: string;
+};
+export declare class TokenOrigin {
+    id: string | null;
+    name: string | null;
+    sourceId: string | null;
+    sourceType?: SourceType | null;
+    referenceOriginId?: string | null;
+    referencePersistentId?: string | null;
+    constructor(model: TokenOriginModel);
+}

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

@@ -0,0 +1,11 @@
+import { TokenOrigin } from "../support/SDKTokenOrigin";
+import { Token } from "../tokens/SDKToken";
+import { AnyToken } from "../tokens/SDKTokenValue";
+export declare class ThemeUtilities {
+    /** Creates duplicate of the token */
+    static replicateTokenAsThemePrefabWithoutValue(token: Token, themeId: string, origin: TokenOrigin | null, versionId: string): AnyToken;
+    /** Creates duplicate of the token */
+    static replicateTokenWithoutValue<T extends AnyToken>(token: T): T;
+    /** Creates duplicate of the token */
+    static replicateTokenWithValue<T extends AnyToken>(token: T): T;
+}

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

@@ -0,0 +1,55 @@
+import { TokenType } from "../enums/SDKTokenType";
+import { Token } from "../tokens/SDKToken";
+import { AnyToken, AnyTokenValue } from "../tokens/SDKTokenValue";
+import { TokenThemeOverrideRemoteModel } from "./SDKTokenThemeOverride";
+export type 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;
+    idInVersion: string;
+    brandId: string;
+    designSystemVersionId: string;
+    name: string;
+    description: string;
+    codeName: string;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    overriddenTokens: Array<Token>;
+    constructor(model: TokenThemeRemoteModel, versionId: string);
+    addOverride(override: Token): void;
+    addOverrides(overrides: Array<Token>): void;
+    toWriteObject(): TokenThemeRemoteModel;
+    private tokensToOverrides;
+    toWriteOverrideObject(token: Token): TokenThemeOverrideRemoteModel;
+    valueToWriteObject(value: AnyTokenValue, type: TokenType, token: AnyToken): import("../tokens/remote/SDKRemoteTokenData").ShadowTokenRemoteData | import("../tokens/remote/SDKRemoteTokenData").GradientTokenRemoteData | {
+        aliasTo: string | undefined;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BlurTokenRemoteValue;
+    } | {
+        aliasTo: string | undefined;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BorderTokenRemoteValue;
+    } | {
+        aliasTo: string | undefined;
+        value: import("../tokens/remote/SDKRemoteTokenValue").ColorTokenRemoteValue;
+    } | {
+        aliasTo: string | undefined;
+        value: import("../tokens/remote/SDKRemoteTokenValue").AnyDimensionTokenRemoteValue;
+    } | {
+        aliasTo: string | undefined;
+        value: string;
+    } | {
+        aliasTo: string | undefined;
+        value: import("../tokens/remote/SDKRemoteTokenValue").TypographyTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,46 @@
+import { TokenType } from "../enums/SDKTokenType";
+import { TokenOrigin } from "../support/SDKTokenOrigin";
+import { AnyTokenValue } from "../tokens/SDKTokenValue";
+import { AnyDimensionTokenRemoteData, AnyOptionTokenRemoteData, AnyStringTokenRemoteData, BlurTokenRemoteData, BorderTokenRemoteData, ColorTokenRemoteData, GradientTokenRemoteData, ShadowTokenRemoteData, TypographyTokenRemoteData } from "../tokens/remote/SDKRemoteTokenData";
+export type TokenThemeOverrideRemoteModel = {
+    data: ColorTokenRemoteData | AnyStringTokenRemoteData | TypographyTokenRemoteData | ShadowTokenRemoteData | AnyDimensionTokenRemoteData | BorderTokenRemoteData | GradientTokenRemoteData | BlurTokenRemoteData | AnyOptionTokenRemoteData;
+    tokenPersistentId: string;
+    type: TokenType;
+    origin: TokenOrigin | null;
+    createdAt?: string;
+    updatedAt?: string;
+};
+export type TokenThemeOverrideTranserObject = {
+    data: ColorTokenRemoteData | AnyStringTokenRemoteData | TypographyTokenRemoteData | ShadowTokenRemoteData | AnyDimensionTokenRemoteData | BorderTokenRemoteData | GradientTokenRemoteData | BlurTokenRemoteData | AnyOptionTokenRemoteData;
+    tokenPersistentId?: string;
+    type?: TokenType;
+};
+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): ShadowTokenRemoteData | GradientTokenRemoteData | {
+        aliasTo: string | undefined;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BlurTokenRemoteValue;
+    } | {
+        aliasTo: string | undefined;
+        value: import("../tokens/remote/SDKRemoteTokenValue").BorderTokenRemoteValue;
+    } | {
+        aliasTo: string | undefined;
+        value: import("../tokens/remote/SDKRemoteTokenValue").ColorTokenRemoteValue;
+    } | {
+        aliasTo: string | undefined;
+        value: import("../tokens/remote/SDKRemoteTokenValue").AnyDimensionTokenRemoteValue;
+    } | {
+        aliasTo: string | undefined;
+        value: string;
+    } | {
+        aliasTo: string | undefined;
+        value: import("../tokens/remote/SDKRemoteTokenValue").TypographyTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,22 @@
+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 { 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;
+    tokenType: TokenType.blur;
+    constructor(versionId: string, baseToken: TokenRemoteModel, value: BlurTokenValue, alias: BlurToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(versionId: string, brandId: string, name: string, description: string, value: object, alias: BlurToken | null, referenceResolver: DTTokenReferenceResolver, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>): BlurToken;
+    static blurValueFromDefinition(definition: object, referenceResolver: DTTokenReferenceResolver): BlurTokenValue;
+    toWriteObject(): BlurTokenRemoteModel;
+    static valueToWriteObject(value: BlurTokenValue): {
+        aliasTo: string | undefined;
+        value: BlurTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,24 @@
+import { DTTokenReferenceResolver } from "../../tools/design-tokens/utilities/SDKDTTokenReferenceResolver";
+import { ElementProperty } from "../elements/SDKElementProperty";
+import { ElementPropertyValue } from "../elements/values/SDKElementPropertyValue";
+import { BorderPosition } from "../enums/SDKBorderPosition";
+import { BorderStyle } from "../enums/SDKBorderStyle";
+import { TokenType } from "../enums/SDKTokenType";
+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;
+    tokenType: TokenType.border;
+    constructor(versionId: string, baseToken: TokenRemoteModel, value: BorderTokenValue, alias: BorderToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(versionId: string, brandId: string, 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;
+    static toBorderStyle(value: any): BorderStyle;
+    static toBorderPosition(value: any): BorderPosition;
+    toWriteObject(): BorderTokenRemoteModel;
+    static valueToWriteObject(value: BorderTokenValue): {
+        aliasTo: string | undefined;
+        value: BorderTokenRemoteValue;
+    };
+}

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

@@ -0,0 +1,34 @@
+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 { ColorTokenRemoteModel, TokenRemoteModel } from "./remote/SDKRemoteTokenModel";
+import { ColorTokenRemoteValue } from "./remote/SDKRemoteTokenValue";
+import { Token } from "./SDKToken";
+import { ColorTokenValue } from "./SDKTokenValue";
+export declare class ColorToken extends Token {
+    value: ColorTokenValue;
+    tokenType: TokenType.color;
+    constructor(versionId: string, baseToken: TokenRemoteModel, value: ColorTokenValue, alias: ColorToken | null, properties: Array<ElementProperty>, propertyValues: Array<ElementPropertyValue>);
+    static create(versionId: string, brandId: string, 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 normalizedHex(value: string | null): string | null;
+    static colorValueFromDefinitionOrReference(definition: string | object, referenceResolver: DTTokenReferenceResolver): ColorTokenValue | undefined;
+    toHex6(): string;
+    toHex8(): string;
+    static hexToColorValue(hex: string): ColorTokenValue;
+    static colorValueToHex6(value: ColorTokenValue): string;
+    static colorValueToHex8(value: ColorTokenValue): string;
+    /** Normalizes any color value to server readable value, and ignores alpha value optionally */
+    static colorStringToNormalizedServerValue(value: string | undefined | null, ignoreAlpha?: boolean): string | null;
+    static normalizedDefaultServerValue(): string;
+    updateWithRawValue(value: Omit<ColorTokenValue, "referencedTokenId">): void;
+    updateWithReferencedValue(value: ColorToken): void;
+    toWriteObject(): ColorTokenRemoteModel;
+    static valueToWriteObject(value: ColorTokenValue): {
+        aliasTo: string | undefined;
+        value: ColorTokenRemoteValue;
+    };
+}