@rocketium/auto-adapt 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,696 @@
+import { fabric } from 'fabric';
+import { IObjectOptions, IPatternOptions, IGradientOptions } from 'fabric/fabric-impl';
+
+type Prettify<T> = {
+    [P in keyof T]: T[P];
+};
+type Radius = {
+    tl?: number;
+    tr?: number;
+    bl?: number;
+    br?: number;
+};
+type AutoFitSizes = [number, number];
+type Scale = {
+    scale: number;
+    scaleX?: never;
+    scaleY?: never;
+} | {
+    scale?: never;
+    scaleX: number;
+    scaleY: number;
+};
+type ObjectFit = 'fill' | 'fit' | 'crop';
+type TextCase = 'uppercase' | 'lowercase' | 'titlecase' | 'none';
+type FontStyle = 'normal' | 'italic' | 'oblique';
+type ORIGIN_X = 'left' | 'center' | 'right';
+type ORIGIN_Y = 'top' | 'middle' | 'bottom';
+type FontMetaData = {
+    fontId: string;
+    fontUrl: string;
+};
+type ObjectPosition = 'top-left' | 'top-center' | 'top-right' | 'center-left' | 'center' | 'center-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'custom';
+type Padding = {
+    all?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+};
+type BorderPosition = 'center' | 'inside' | 'outside';
+type Border = {
+    color?: string;
+    style?: 'dashed' | 'solid';
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+    position?: BorderPosition;
+    dashWidth?: number;
+    dashGap?: number;
+    dashCap?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    strokeDashArray?: number[];
+};
+type FillOptions = IGradientOptions | IPatternOptions | string;
+type SerializedFillType = string | IPatternOptions | IGradientOptions;
+type SerializedFabricShadow = Pick<fabric.Shadow, 'color' | 'blur' | 'offsetX' | 'offsetY'>;
+type SerializedImageFilter = {
+    brightness?: number;
+    saturation?: number;
+    contrast?: number;
+    invert?: boolean;
+    blur?: number;
+};
+type ColorMap = {
+    [key: string]: FillOptions;
+};
+declare const CANVAS_EDITOR_ELEMENT: {
+    readonly TEXT: "TEXT";
+    readonly SHAPE: "SHAPE";
+    readonly IMAGE: "IMAGE";
+    readonly GROUP: "GROUP";
+    readonly CREATIVE_BOX: "CREATIVE_BOX";
+    readonly VIDEO: "VIDEO";
+    readonly AUDIO: "AUDIO";
+    readonly CANVAS_MASK: "CANVAS_MASK";
+};
+type CANVAS_EDITOR_ELEMENT_TYPE = (typeof CANVAS_EDITOR_ELEMENT)[keyof typeof CANVAS_EDITOR_ELEMENT];
+declare enum CreativeElementCategory {
+    HERO_IMAGE = "HERO_IMAGE",
+    PRODUCT_IMAGE = "PRODUCT_IMAGE",
+    BACKGROUND = "BACKGROUND",
+    LOGO = "LOGO",
+    ICON = "ICON",
+    HEADLINE = "HEADLINE",
+    SUBHEADLINE = "SUBHEADLINE",
+    BODY_COPY = "BODY_COPY",
+    PRICE = "PRICE",
+    CTA = "CTA",
+    TERMS_CONDITIONS = "TERMS_CONDITIONS",
+    REVIEWS_TESTIMONIALS = "REVIEWS_TESTIMONIALS",
+    WARRANTY_INFO = "WARRANTY_INFO",
+    BADGE = "BADGE",
+    NEW_PRODUCT_LABEL = "NEW_PRODUCT_LABEL",
+    OTHER = "OTHER"
+}
+type LayerRules = {
+    editingLocked?: boolean;
+    maxCharCount?: number;
+};
+type GroupPath = string | null;
+declare enum WORD_STYLE_TYPE {
+    WORD_STYLE = "WORD_STYLE",
+    MISSING_GLYPH = "MISSING_GLYPH",
+    VARIABLES = "VARIABLES"
+}
+type WordStyleStyles = {
+    fontFamily?: string;
+    fontSize?: number;
+    fontSizeUnit?: 'px' | '%';
+    fontWeight?: string | number;
+    fontStyle?: FontStyle;
+    textDecoration?: string;
+    textAlign?: string;
+    textBackgroundColor?: string;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    deltaY?: number;
+    linethrough?: boolean;
+    underline?: boolean;
+    subscript?: boolean;
+    superscript?: boolean;
+    linethroughOffset?: number;
+    underlineOffset?: number;
+    offsets?: {
+        linethrough?: number;
+        underline?: number;
+        overline?: number;
+    };
+};
+type WordStyle = {
+    id: string;
+    type?: WORD_STYLE_TYPE;
+    variableId?: string;
+    fontMetaDataWS?: {
+        fontId?: string;
+        fontUrl?: string;
+        name?: string;
+    } | null;
+    data: {
+        start: number;
+        end: number;
+        styles: WordStyleStyles;
+    };
+};
+type WordStyles = Array<WordStyle>;
+type Point = {
+    x: number;
+    y: number;
+};
+type TranslateKeyframes = {
+    id: string;
+    offset: number;
+    x: number;
+    y: number;
+    P1?: Point;
+    P2?: Point;
+};
+type ScaleKeyframes = {
+    id: string;
+    offset: number;
+    scaleX: number;
+    scaleY: number;
+};
+type RotateKeyframes = {
+    id: string;
+    offset: number;
+    angle: number;
+};
+type OpacityKeyframes = {
+    id: string;
+    offset: number;
+    opacity: number;
+};
+type AnimationTrack = {
+    translate?: TranslateKeyframes[];
+    scale?: ScaleKeyframes[];
+    rotate?: RotateKeyframes[];
+    opacity?: OpacityKeyframes[];
+};
+type AnimationReference = Partial<{
+    coordinates: Point;
+    origin: Point;
+    scale: Point;
+    rotate: number;
+    opacity: number;
+    track: AnimationTrack;
+    originalReference: AnimationReference;
+}>;
+declare enum TextAnimationType {
+    CHARACTER = "character",
+    WORD = "word",
+    LINE = "line"
+}
+declare enum AnimationSpecialCase {
+    TYPING_EFFECT = "typing-effect",
+    NONE = "none"
+}
+type TextAnimationKeyframe = {
+    offset: number;
+    y?: number;
+    opacity?: number;
+};
+type TextAnimation = {
+    _id: string;
+    type: TextAnimationType;
+    clipped?: boolean;
+    reverse?: boolean;
+    specialCase?: AnimationSpecialCase | null;
+    name: string;
+    keyframes: TextAnimationKeyframe[];
+    start: number;
+    end: number;
+    loop?: number;
+};
+type SerializedRoundedRect = SerializedFabricBaseObject & {
+    properties?: {
+        layerStartTime?: number;
+        layerEndTime?: number;
+        visible?: boolean;
+        fill?: string;
+        outputFormat?: string;
+        layerRules?: LayerRules;
+        clipPathId?: string;
+        clipPathParentId?: string;
+    };
+    animatable?: boolean;
+};
+type SerializedFabricBaseObject = Pick<IObjectOptions, 'originX' | 'originY' | 'left' | 'top' | 'width' | 'height' | 'stroke' | 'strokeWidth' | 'strokeDashArray' | 'strokeLineCap' | 'strokeDashOffset' | 'strokeLineJoin' | 'strokeUniform' | 'strokeMiterLimit' | 'scaleX' | 'scaleY' | 'angle' | 'flipX' | 'flipY' | 'opacity' | 'visible' | 'backgroundColor' | 'fillRule' | 'paintFirst' | 'globalCompositeOperation' | 'skewX' | 'skewY' | 'data' | 'selectable' | 'hoverCursor' | 'moveCursor' | 'hasControls' | 'hasBorders' | 'lockRotation' | 'lockMovementY' | 'lockScalingX' | 'lockScalingY' | 'lockSkewingX' | 'lockSkewingY' | 'lockScalingFlip' | 'inverted' | 'absolutePositioned' | 'centeredScaling'> & {
+    version: '5.3.0';
+    type: 'rect' | 'circle' | 'triangle' | 'line' | 'polygon' | 'polyline' | 'path' | 'group' | 'image' | 'text' | 'rounded-rect' | 'text-container' | 'image-container' | 'custom-textbox' | 'shape-container' | 'video-container' | 'audio-container' | 'svg-container' | 'group-container';
+    fill?: SerializedFillType;
+    shadow?: SerializedFabricShadow;
+    globalCompositeOperation: GlobalCompositeOperation;
+    rx?: number;
+    ry?: number;
+    evented?: boolean;
+    clipPath?: SerializedRoundedRect;
+};
+type BaseElementJSON = {
+    id: string;
+    type: SerializedFabricBaseObject['type'];
+    displayText: string;
+    dataType: CANVAS_EDITOR_ELEMENT_TYPE;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    angle: number;
+    opacity: number;
+    shadow: SerializedFabricShadow | null;
+    visible: boolean;
+    globalCompositeOperation: GlobalCompositeOperation;
+    selectable: boolean;
+    fill: SerializedFillType;
+    border: Border;
+    padding: Padding;
+    cornerRadius: Radius;
+    layerRules?: LayerRules;
+    groupPath: GroupPath;
+    animationTrack?: AnimationTrack;
+    animationReference?: AnimationReference;
+    scaleX?: number;
+    scaleY?: number;
+    category?: CreativeElementCategory;
+};
+type CreativeBoxJSON = Omit<BaseElementJSON, 'left' | 'top' | 'angle' | 'opacity' | 'shadow' | 'visible' | 'globalCompositeOperation' | 'selectable' | 'border' | 'padding' | 'cornerRadius' | 'layerRules'> & {
+    type: 'rect';
+    dataType: 'CREATIVE_BOX';
+    zIndex: number;
+    layerRules?: LayerRules;
+};
+type ImageContainerJSON = Omit<BaseElementJSON, 'type'> & {
+    type: 'image-container';
+    dataType: 'IMAGE';
+    objectPosition: ObjectPosition;
+    imageOriginX: ORIGIN_X;
+    imageOriginY: ORIGIN_Y;
+    imageScale: number;
+    imageRotation: number;
+    imageLeft: number;
+    imageTop: number;
+    imageWidth: number;
+    imageHeight: number;
+    objectFit: ObjectFit;
+    src: string;
+    layerStartTime?: number;
+    layerEndTime?: number;
+    propertiesVisible?: boolean;
+    exportSrc?: string;
+    originalSrc?: string;
+    displayText: string;
+    layerRules?: LayerRules;
+    flipX?: boolean;
+    flipY?: boolean;
+    filter?: Partial<SerializedImageFilter>;
+    animationTrack?: AnimationTrack;
+    animationReference?: AnimationReference;
+};
+type PathJSON = Omit<BaseElementJSON, 'border' | 'padding' | 'cornerRadius'> & {
+    type: 'shape-container';
+    dataType: 'SHAPE';
+    path: (string | number)[][];
+    layerStartTime?: number;
+    layerEndTime?: number;
+    propertiesVisible?: boolean;
+    propertiesFill?: string;
+    layerRules?: LayerRules;
+} & Scale;
+type RoundedRectJSON = Omit<BaseElementJSON, 'border' | 'padding'> & {
+    type: 'rounded-rect';
+    dataType: 'SHAPE';
+    scale: number;
+    layerStartTime?: number;
+    layerEndTime?: number;
+    propertiesVisible?: boolean;
+    propertiesFill?: string;
+    displayText: string;
+    layerRules?: LayerRules;
+};
+type TextContainerJSON = Omit<BaseElementJSON, 'type'> & {
+    type: 'text-container';
+    dataType: 'TEXT';
+    autoFit: boolean;
+    autoFitSizes: [number | null, number | null];
+    textCase: TextCase;
+    serializedText: string;
+    fontMetaData: FontMetaData;
+    objectPosition: ObjectPosition;
+    textleft: number;
+    textTop: number;
+    textHeight: number;
+    textFill: SerializedFillType;
+    fontFamily: string;
+    fontWeight: number | string;
+    fontSize: number;
+    text: string;
+    underline: boolean;
+    overline: boolean;
+    linethrough: boolean;
+    textAlign: string;
+    fontStyle: '' | 'normal' | 'italic' | 'oblique';
+    lineHeight: number;
+    charSpacing: number;
+    styles: unknown[];
+    wordStyle: WordStyles;
+    missingGlyphChars: [];
+    layerStartTime?: number;
+    layerEndTime?: number;
+    propertiesVisible?: boolean;
+    wordSpacing?: number;
+    offsets: {
+        linethrough?: number;
+    };
+    linethroughOffset: -0.315;
+    underlineOffset: 0.1;
+    displayText: string;
+    textAnimationTrack?: TextAnimation;
+};
+type VideoContainerJSON = Omit<BaseElementJSON, 'type'> & {
+    type: 'video-container';
+    dataType: 'VIDEO';
+    objectPosition: ObjectPosition;
+    imageScale: number;
+    imageLeft: number;
+    imageTop: number;
+    imageWidth: number;
+    imageHeight: number;
+    objectFit: ObjectFit;
+    src: string;
+    layerStartTime?: number;
+    layerEndTime?: number;
+    propertiesVisible?: boolean;
+    volume?: number;
+    trimmerStartTime?: number;
+    displayText: string;
+    layerRules?: LayerRules;
+    imageOriginX: ORIGIN_X;
+    imageOriginY: ORIGIN_Y;
+    flipX: boolean;
+    flipY: boolean;
+    filter: Partial<SerializedImageFilter>;
+    imageRotation: number;
+    originalSrc?: string;
+    exportSrc?: string;
+    animationTrack?: AnimationTrack;
+    animationReference?: AnimationReference;
+};
+type AudioContainerJSON = {
+    type: 'audio-container';
+    dataType: 'AUDIO';
+    src: string;
+    layerStartTime?: number;
+    layerEndTime?: number;
+    volume?: number;
+    id: string;
+    displayText: string;
+    selectable?: boolean;
+    trimmerStartTime?: number;
+    layerRules?: LayerRules;
+};
+type SvgJSON = Omit<BaseElementJSON, 'border' | 'padding' | 'cornerRadius' | 'fill'> & {
+    type: 'svg-container';
+    dataType: 'SHAPE';
+    src: string;
+    layerStartTime?: number;
+    layerEndTime?: number;
+    propertiesVisible?: boolean;
+    objectFit?: ObjectFit;
+    imageRotation?: number;
+    objectPosition?: ObjectPosition;
+    imageLeft?: number;
+    imageTop?: number;
+    imageWidth?: number;
+    imageHeight?: number;
+    flipX?: boolean;
+    flipY?: boolean;
+    imageScale: number;
+    animationTrack?: AnimationTrack;
+    animationReference?: AnimationReference;
+    colorMap?: ColorMap;
+    imageOriginX?: ORIGIN_X;
+    imageOriginY?: ORIGIN_Y;
+} & Scale;
+type GroupContainerJSON = Omit<BaseElementJSON, 'type' | 'fill' | 'border' | 'padding' | 'cornerRadius' | 'layerRules'> & {
+    type: 'group-container';
+    dataType: 'GROUP';
+    objects: string[];
+    isAlreadyGrouped: boolean;
+    isMaskedGroup: boolean;
+    propertiesVisible?: boolean;
+    layerRules?: LayerRules;
+};
+type CanvasElementJSON = CreativeBoxJSON | ImageContainerJSON | PathJSON | RoundedRectJSON | TextContainerJSON | VideoContainerJSON | AudioContainerJSON | SvgJSON | GroupContainerJSON;
+type CanvasElementWithOverrides<T extends CanvasElementJSON> = Prettify<T & {
+    zIndex: number;
+    overrides: Record<string, Partial<T> & {
+        zIndex: number;
+    }>;
+}>;
+
+type DatabaseVariant = {
+    id: string;
+    sizes: Record<string, DatabaseSize>;
+    objects: Record<string, CanvasElementWithOverrides<CanvasElementJSON>>;
+};
+type DatabaseSize = {
+    width: number;
+    height: number;
+    id: string;
+    rulers: Record<string, RulerLine>;
+    showRulers?: boolean;
+    showGrid: boolean;
+    grid?: GridOption;
+    rulersLocked?: boolean;
+    displayName: string;
+    videoLength?: number;
+};
+declare const RULER_AXIS: {
+    readonly X: "x";
+    readonly Y: "y";
+};
+type RULER_AXIS_TYPE = (typeof RULER_AXIS)[keyof typeof RULER_AXIS];
+type RulerLine = {
+    axis: RULER_AXIS_TYPE;
+    value: number;
+    id: string;
+};
+type GridOption = {
+    size: number;
+    unit: 'PIXEL';
+    color: string;
+    subdivisions: number;
+};
+type SavedCustomDimensions = {
+    active: boolean;
+    name: string;
+    creativeUrl: string;
+    thumbnail?: string;
+    width?: number;
+    height?: number;
+    fileName?: string;
+    fileNameSource?: 'formula' | 'manual';
+};
+type OutputFormat = 'image' | 'video';
+interface ServerCapsule {
+    videoLength: number;
+    name: string;
+    image: string;
+    author: string;
+    timestamp: string;
+    version: number;
+    isDeleted: boolean;
+    collaborators: string[];
+    tags: string[];
+    orientation: string;
+    videoBackground: string;
+    branding: boolean;
+    outputFormat: OutputFormat;
+    brandPalettes: [];
+    capsuleErrors: [];
+    withCanvas: boolean;
+    creativesOrder: string[];
+    _id: string;
+    capsuleId: string;
+    audio: {
+        link: string;
+    };
+    authorId: string;
+    canvasData: {
+        metadata: {};
+        variant: DatabaseVariant;
+    };
+    cards: {
+        id: string;
+        tags: string[];
+        type: string;
+        groups: [];
+        image: string;
+        options: [];
+        autoTimeBasedOnElements: boolean;
+    }[];
+    createdAt: string;
+    createdUsingStylingPanel: null;
+    customDimensions: {
+        _id: string;
+        width: number;
+        height: number;
+    };
+    exportSettings: {
+        quality: string;
+    };
+    lastModified: string;
+    lastModifiedId: string;
+    listId: string;
+    logoImage: string;
+    logoLoop: boolean;
+    logoPosition: string;
+    logoSize: number;
+    metadata: {
+        platform: string;
+        shareString: string;
+        isSaved: boolean;
+        name: string;
+        assetGroup: string;
+        email: string;
+    };
+    savedCustomDimensions: Record<string, SavedCustomDimensions>;
+    shortId: string;
+    teamId: string;
+    themeId: string;
+    title: string;
+    updatedAt: string;
+    videoBackgroundExtraClasses: string;
+    videoIndex: number;
+    videoStyling: null;
+    videoTemplateRules: null;
+    visibility: string;
+    newAddedSizes?: Record<string, SavedCustomDimensions>;
+    sourceCapsuleId?: string | null;
+}
+
+declare const getAdaptedObjectsJSON: ({ adaptSize, objects, closestSize, }: {
+    adaptSize: string;
+    objects: Record<string, CanvasElementJSON>;
+    closestSize: string;
+}) => Record<string, CanvasElementJSON>;
+/**
+ * Resolve CanvasElementWithOverrides to flat CanvasElementJSON for a given sizeId.
+ * Applies overrides[sizeId] onto the base object.
+ */
+declare const resolveObjectsForSize: (objects: Record<string, CanvasElementWithOverrides<CanvasElementJSON>>, sizeId: string) => Record<string, CanvasElementJSON>;
+/**
+ * Convert adapted flat objects back to overrides on the original objects.
+ * For each layer, the adapted result is stored as overrides[newSizeId].
+ */
+declare const applyAdaptedAsOverrides: (originalObjects: Record<string, CanvasElementWithOverrides<CanvasElementJSON>>, adaptedObjects: Record<string, CanvasElementJSON>, newSizeId: string) => Record<string, CanvasElementWithOverrides<CanvasElementJSON>>;
+/**
+ * Builds a new ServerCapsule with an added size. Handles canvasData.variant.sizes,
+ * savedCustomDimensions, newAddedSizes, and creativesOrder.
+ */
+declare const buildNewCapsule: ({ originalCapsule, updatedObjects, sizeId, referenceCreativeId, sizeToGenerate, sizeName, sizeCategory, videoLength, }: {
+    originalCapsule: ServerCapsule;
+    updatedObjects: Record<string, CanvasElementWithOverrides<CanvasElementJSON>>;
+    sizeId: string;
+    referenceCreativeId: string;
+    sizeToGenerate: string;
+    sizeName?: string;
+    sizeCategory?: string;
+    videoLength?: number;
+}) => ServerCapsule;
+/**
+ * Generate a base layout for a new size.
+ *
+ * Takes the original capsule and target size params, returns a new ServerCapsule
+ * with the adapted layout. Follows the frontend's getAdaptedObjectsJSON logic exactly.
+ */
+declare const generateBaseLayoutForSize: ({ originalCapsule, capsuleId, creativeId, sizeId, sizeToGenerate, sizeName, sizeCategory, }: {
+    originalCapsule: ServerCapsule;
+    capsuleId: string;
+    creativeId: string | null;
+    sizeId: string;
+    sizeToGenerate: string;
+    sizeName?: string;
+    sizeCategory?: string;
+}) => ServerCapsule;
+
+declare const getNormalizedSizeValue: (sizeValue: string) => string;
+declare const getEuclideanDistanceBetweenSizes: ({ size1, size2 }: {
+    size1: string;
+    size2: string;
+}) => number;
+/**
+ * Finds the closest match among string-based sizes (e.g. ['720x720', '1080x1920']).
+ * Returns the single best match and all sorted match percentages.
+ */
+declare const findClosestSizeWithMatches: ({ availableSizes, adaptSize, }: {
+    availableSizes: string[];
+    adaptSize: string;
+}) => {
+    closestSize: string;
+    sortedMatches: Record<string, number>;
+};
+/**
+ * Finds closest matches among size objects (Record<sizeId, DatabaseSize>).
+ * Returns enriched size objects with _id and matchPercentage, sorted descending.
+ */
+declare const findClosestSizeObjectsWithMatches: ({ availableSizes, adaptSize, }: {
+    availableSizes: Record<string, DatabaseSize>;
+    adaptSize: string;
+}) => (DatabaseSize & {
+    _id: string;
+    matchPercentage: number;
+})[];
+/**
+ * Find the best reference size from available size objects.
+ * Uses weighted scoring: 90% aspect-ratio similarity, 10% euclidean distance.
+ * Returns the sizeId (key) of the best match.
+ */
+declare const findBestReferenceSize: (availableSizes: Record<string, DatabaseSize>, targetSize: string) => string;
+
+declare const getAreaPercentageOfElementOnCanvasJSON: ({ element, canvasDimensions, }: {
+    element: CanvasElementJSON;
+    canvasDimensions: {
+        height: number;
+        width: number;
+    };
+}) => number;
+declare const checkIfElementShouldBeSkewed: ({ areaPercentage, referenceLengths, type, }: {
+    areaPercentage: number;
+    referenceLengths: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        canvasWidth: number;
+        canvasHeight: number;
+    };
+    type: string;
+}) => boolean;
+declare const scaleCornerRadius: (cornerRadius: Radius | undefined, scalingRatio: number) => Radius;
+declare const scalePadding: (padding: Padding | undefined, scalingRatio: number) => Padding;
+declare const getScaledBorderJSON: ({ object, scalingRatio, }: {
+    object: CanvasElementJSON;
+    scalingRatio: number;
+}) => {
+    border?: Border;
+};
+declare const adaptWordStyleFontSizes: ({ wordStyle, scalingRatio, }: {
+    wordStyle: WordStyle[];
+    scalingRatio: number;
+}) => WordStyle[];
+declare const scaleAutoFitSizes: (autoFitSizes: [number | null, number | null] | undefined, scalingRatio: number, fallbackHeight: number) => AutoFitSizes;
+declare const getValuesWithoutSkewingJSON: ({ closestSize, adaptSize, object, }: {
+    closestSize: string;
+    adaptSize: string;
+    object: CanvasElementJSON;
+}) => {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+
+declare const isTextJSON: (object: CanvasElementJSON) => object is TextContainerJSON;
+declare const isImageJSON: (object: CanvasElementJSON) => object is ImageContainerJSON;
+declare const isShapeJSON: (object: CanvasElementJSON) => object is PathJSON | RoundedRectJSON | SvgJSON;
+declare const isSVGContainerJSON: (object: CanvasElementJSON) => object is SvgJSON;
+declare const isRoundedRectJSON: (object: CanvasElementJSON) => object is RoundedRectJSON;
+declare const isGroupJSON: (object: CanvasElementJSON | undefined) => object is GroupContainerJSON;
+declare const isCreativeBoxJSON: (object: CanvasElementJSON) => boolean;
+declare const isAudioJSON: (object: CanvasElementJSON) => boolean;
+
+export { type AnimationReference, AnimationSpecialCase, type AnimationTrack, type AudioContainerJSON, type AutoFitSizes, type BaseElementJSON, type Border, type BorderPosition, CANVAS_EDITOR_ELEMENT, type CANVAS_EDITOR_ELEMENT_TYPE, type CanvasElementJSON, type CanvasElementWithOverrides, type ColorMap, type CreativeBoxJSON, CreativeElementCategory, type DatabaseSize, type DatabaseVariant, type FillOptions, type FontMetaData, type FontStyle, type GridOption, type GroupContainerJSON, type GroupPath, type ImageContainerJSON, type LayerRules, type ORIGIN_X, type ORIGIN_Y, type ObjectFit, type ObjectPosition, type OpacityKeyframes, type OutputFormat, type Padding, type PathJSON, type Point, type Prettify, RULER_AXIS, type RULER_AXIS_TYPE, type Radius, type RotateKeyframes, type RoundedRectJSON, type RulerLine, type SavedCustomDimensions, type Scale, type ScaleKeyframes, type SerializedFabricBaseObject, type SerializedFabricShadow, type SerializedFillType, type SerializedImageFilter, type SerializedRoundedRect, type ServerCapsule, type SvgJSON, type TextAnimation, type TextAnimationKeyframe, TextAnimationType, type TextCase, type TextContainerJSON, type TranslateKeyframes, type VideoContainerJSON, WORD_STYLE_TYPE, type WordStyle, type WordStyleStyles, type WordStyles, adaptWordStyleFontSizes, applyAdaptedAsOverrides, buildNewCapsule, checkIfElementShouldBeSkewed, findBestReferenceSize, findClosestSizeObjectsWithMatches, findClosestSizeWithMatches, generateBaseLayoutForSize, getAdaptedObjectsJSON, getAreaPercentageOfElementOnCanvasJSON, getEuclideanDistanceBetweenSizes, getNormalizedSizeValue, getScaledBorderJSON, getValuesWithoutSkewingJSON, isAudioJSON, isCreativeBoxJSON, isGroupJSON, isImageJSON, isRoundedRectJSON, isSVGContainerJSON, isShapeJSON, isTextJSON, resolveObjectsForSize, scaleAutoFitSizes, scaleCornerRadius, scalePadding };