@aurigma/design-atoms-model/Product/Container.d.ts

Design Atoms is a part of Customer's Canvas SDK which allows for manipulating individual design elements through your code.

import { ModelComponent } from "./ModelComponent";
import { RectangleF } from "../Math/RectangleF";
import { SizeF } from "../Math/SizeF";
import { BaseItem, ImageItem } from "./Items";
import { Collection } from "../Collection";
import { RenderingType } from "./RenderingType";
import { Color, ColorSpace, RgbColor } from "../Colors";
import { ContainerVisualization } from "./ContainerVisualization";
import { PrintingTechniqueConstraints } from "./Constraints/PrintingTechniqueConstraints";
import { ContainerConstraints } from "./Constraints/ContainerConstraints";
import { Format } from "./Format";
import { Dither } from "./Dither";
export declare class Container extends ModelComponent {
    static type: string;
    readonly type: string;
    parentComponent: ModelComponent;
    translationKey: string;
    renderingGroupName?: string;
    protected _locked: boolean;
    private readonly _items;
    private _visible;
    private _region;
    get renderingType(): RenderingType;
    constructor(initialItems?: BaseItem[], name?: string);
    get region(): RectangleF;
    set region(value: RectangleF);
    get items(): Collection<BaseItem>;
    get visible(): boolean;
    set visible(value: boolean);
    get locked(): boolean;
    set locked(value: boolean);
    private _onItemAdded;
    private _onItemRemoved;
    getSimplifiedObject(): Object;
    generateNewIds(): void;
    protected _copy(source: Container, destination: Container, generateNewIds: boolean): void;
    clone(generateNewIds?: boolean): Container;
    private _onRegionChanged;
}
export declare class MockupContainer extends Container {
    noPrint: boolean;
    noShow: boolean;
    size: SizeF;
    constructor(initialItems?: BaseItem[], name?: string);
    protected _copy(source: MockupContainer, destination: MockupContainer, generateNewIds: boolean): void;
    clone(generateNewIds?: boolean): MockupContainer;
}
export declare class SurfaceContainer extends Container {
    static type: string;
    readonly type: string;
    printingTechniqueConstraints: PrintingTechniqueConstraints;
    constraints: ContainerConstraints;
    constructor(initialItems?: BaseItem[], name?: string);
    protected _copy(source: SurfaceContainer, destination: SurfaceContainer, generateNewIds: boolean): void;
    clone(generateNewIds?: boolean): SurfaceContainer;
    getSimplifiedObject(): {
        printingTechniqueConstraints: {
            allowRasterElements: boolean;
            minWidth: number;
            minFontSize: number;
            targetDpi: number;
        };
        constraints: {
            maxArtworkSize: {
                width: number;
                height: number;
                shapeType: import(".").ArtworkShapeType;
            };
        };
        constructor: Function;
        toString(): string;
        toLocaleString(): string;
        valueOf(): Object;
        hasOwnProperty(v: PropertyKey): boolean;
        isPrototypeOf(v: Object): boolean;
        propertyIsEnumerable(v: PropertyKey): boolean;
    };
}
export declare class ColorLessContainer extends SurfaceContainer {
    static type: string;
    readonly type: string;
    outputColor: Color;
    opaque: boolean;
    dpi: number | null;
    visualization: ContainerVisualization | null;
    private _format;
    private _dither;
    private _amount;
    get format(): Format;
    set format(value: Format);
    get dither(): Dither;
    set dither(value: Dither);
    get amount(): number;
    set amount(value: number);
    get renderingType(): RenderingType;
    constructor(initialItems?: BaseItem[], name?: string);
    protected _copy(source: ColorLessContainer, destination: ColorLessContainer, generateNewIds: boolean): void;
    getSimplifiedObject(): {
        outputColor: import("../Colors").IColor;
        opaque: boolean;
        dpi: number;
        visualization: object;
        format: Format;
        dither: Dither;
        amount: number;
        printingTechniqueConstraints: {
            allowRasterElements: boolean;
            minWidth: number;
            minFontSize: number;
            targetDpi: number;
        };
        constraints: {
            maxArtworkSize: {
                width: number;
                height: number;
                shapeType: import(".").ArtworkShapeType;
            };
        };
        constructor: Function;
        toString(): string;
        toLocaleString(): string;
        valueOf(): Object;
        hasOwnProperty(v: PropertyKey): boolean;
        isPrototypeOf(v: Object): boolean;
        propertyIsEnumerable(v: PropertyKey): boolean;
    };
    clone(generateNewIds?: boolean): SurfaceContainer;
}
export declare class LimitedColorContainer extends SurfaceContainer {
    static type: string;
    readonly type: string;
    maxColorNumber: number | null;
    paletteUId: string | null;
    get renderingType(): RenderingType;
    constructor(initialItems?: BaseItem[], name?: string);
    protected _copy(source: LimitedColorContainer, destination: LimitedColorContainer, generateNewIds: boolean): void;
    getSimplifiedObject(): {
        maxColorNumber: number;
        paletteUId: string;
        printingTechniqueConstraints: {
            allowRasterElements: boolean;
            minWidth: number;
            minFontSize: number;
            targetDpi: number;
        };
        constraints: {
            maxArtworkSize: {
                width: number;
                height: number;
                shapeType: import(".").ArtworkShapeType;
            };
        };
        constructor: Function;
        toString(): string;
        toLocaleString(): string;
        valueOf(): Object;
        hasOwnProperty(v: PropertyKey): boolean;
        isPrototypeOf(v: Object): boolean;
        propertyIsEnumerable(v: PropertyKey): boolean;
    };
    clone(generateNewIds?: boolean): SurfaceContainer;
}
export declare class FullColorContainer extends SurfaceContainer {
    static type: string;
    readonly type: string;
    colorSpace: ColorSpace | null;
    colorProfile: string | null;
    get renderingType(): RenderingType;
    constructor(initialItems?: BaseItem[], name?: string);
    protected _copy(source: FullColorContainer, destination: FullColorContainer, generateNewIds: boolean): void;
    getSimplifiedObject(): {
        colorSpace: ColorSpace;
        colorProfile: string;
        printingTechniqueConstraints: {
            allowRasterElements: boolean;
            minWidth: number;
            minFontSize: number;
            targetDpi: number;
        };
        constraints: {
            maxArtworkSize: {
                width: number;
                height: number;
                shapeType: import(".").ArtworkShapeType;
            };
        };
        constructor: Function;
        toString(): string;
        toLocaleString(): string;
        valueOf(): Object;
        hasOwnProperty(v: PropertyKey): boolean;
        isPrototypeOf(v: Object): boolean;
        propertyIsEnumerable(v: PropertyKey): boolean;
    };
    clone(generateNewIds?: boolean): SurfaceContainer;
}
export declare class SpotColorContainer extends SurfaceContainer {
    static type: string;
    readonly type: string;
    previewColor: RgbColor;
    outputColor: Color;
    get renderingType(): RenderingType;
    constructor();
    protected _copy(source: SpotColorContainer, destination: SpotColorContainer, generateNewIds: boolean): void;
    clone(generateNewIds?: boolean): SpotColorContainer;
}
export declare class TextureContainer extends SurfaceContainer {
    constructor();
    get renderingType(): RenderingType;
    _previewTextureSource: ImageItem.ImageSource;
    get previewTextureSource(): ImageItem.ImageSource;
    set previewTextureSource(previewTextureSource: ImageItem.ImageSource);
    static type: string;
    previewTextureName: string;
    outputColor: Color;
    readonly type: string;
    protected _copy(source: TextureContainer, destination: TextureContainer, generateNewIds: boolean): TextureContainer;
    clone(generateNewIds?: boolean): TextureContainer;
    getSimplifiedObject(omitProperties?: string[] | string): {
        printingTechniqueConstraints: {
            allowRasterElements: boolean;
            minWidth: number;
            minFontSize: number;
            targetDpi: number;
        };
        constraints: {
            maxArtworkSize: {
                width: number;
                height: number;
                shapeType: import(".").ArtworkShapeType;
            };
        };
        constructor: Function;
        toString(): string;
        toLocaleString(): string;
        valueOf(): Object;
        hasOwnProperty(v: PropertyKey): boolean;
        isPrototypeOf(v: Object): boolean;
        propertyIsEnumerable(v: PropertyKey): boolean;
    };
}