import { TransformMatrix } from '../../helpers.js';
import { ColorInput, GeometricBounds, Transform } from '../../types/index.js';
import { Spread } from '../Spread.js';
import { IDMLSpreadPackageContext } from '../SpreadPackage.js';
import { RectangleSprite } from './Rectangle.js';
import { OvalSprite } from './Oval.js';
import { PolygonSprite } from './Polygon.js';
import { GroupSprite } from './Group.js';
import { Color } from '../Color.js';
import { Gradient } from '../Gradient.js';
import { MergedObjectStyle } from '../ObjectStyle.js';
export type SpriteWithChildren = RectangleSprite | OvalSprite | PolygonSprite | GroupSprite;
export type BlendingSetting = {
    opacity: number;
    blendMode?: string;
};
export type DropShadowSetting = {
    mode: 'drop';
    xOffset: number;
    yOffset: number;
    size: number;
    effectColorId: string;
    spread: number;
    opacity: number;
};
export type TransparencySetting = {
    blendingSetting?: BlendingSetting;
    dropShadowSetting?: DropShadowSetting;
};
export type DropShadowInput = {
    mode: 'drop';
    xOffset: number;
    yOffset: number;
    size: number;
    effectColor: ColorInput;
    spread: number;
    opacity: number;
};
export type SpriteOpts = {
    name?: string;
    parentPageId?: string;
    appliedObjectStyleId?: string;
    itemTransform: TransformMatrix;
    storyTitle?: string;
    contentType?: string;
    visible?: boolean;
    nonprinting?: boolean;
    itemLayerId?: string;
    horizontalLayoutConstraints?: HorizontalLayoutConstraints;
    verticalLayoutConstraints?: VerticalLayoutConstraints;
    fillColorId?: string;
    fillTint?: number;
    gradientStart?: [number, number];
    gradientFillLength?: number;
    gradientFillAngle?: number;
    gradientStrokeStart?: [number, number];
    gradientStrokeLength?: number;
    gradientStrokeAngle?: number;
    strokeColorId?: string;
    strokeTint?: number;
    strokeWeight?: number;
    strokeAlignment?: string;
    frameFittingOption?: FrameFittingOption;
    objectExportOption?: ObjectExportOption;
    textWrapPreference?: TextWrapPreference;
    inCopyExportOption?: InCopyExportOption;
    transparencySetting?: TransparencySetting;
};
export type LayoutDimension = 'fixedDimension' | 'flexibleDimension';
export type HorizontalLayoutConstraints = [LayoutDimension, LayoutDimension, LayoutDimension];
export type VerticalLayoutConstraints = [LayoutDimension, LayoutDimension, LayoutDimension];
/** Bluepic stroke alignment (matches @bluepic/types StrokeAlignment). */
export type StrokeAlignment = 'inside' | 'center' | 'outside';
export type FrameFittingOption = {
    sourceElement: Element;
};
export type ObjectExportOption = {
    sourceElement: Element;
};
export type TextWrapPreference = {
    sourceElement: Element;
};
export type InCopyExportOption = {
    sourceElement: Element;
};
export declare abstract class Sprite {
    private id;
    type: string;
    context: IDMLSpreadPackageContext;
    private name?;
    private parentPageId?;
    getParentPage(): import("../Page.js").Page;
    private appliedObjectStyleId?;
    itemTransform: TransformMatrix;
    private storyTitle?;
    private contentType?;
    private visible?;
    private nonprinting?;
    private itemLayerId?;
    private horizontalLayoutConstraints?;
    private verticalLayoutConstraints?;
    private fillColorId?;
    private fillTint?;
    private gradientStart?;
    private gradientFillLength?;
    private gradientFillAngle?;
    private gradientStrokeStart?;
    private gradientStrokeLength?;
    private gradientStrokeAngle?;
    private strokeColorId?;
    private strokeTint?;
    private strokeWeight?;
    private strokeAlignment?;
    private frameFittingOption?;
    private objectExportOption?;
    private textWrapPreference?;
    private inCopyExportOption?;
    private transparencySetting?;
    constructor(id: string, type: string, opts: SpriteOpts, context: IDMLSpreadPackageContext);
    getId(): string;
    abstract getGeometricBounds(): GeometricBounds;
    get parentSpread(): Spread;
    getFillColor(): Color | undefined;
    getFillGradient(): Gradient | undefined;
    getGradientFillAngle(): number | undefined;
    isStrokeNone(): boolean;
    getStrokeColor(): Color | undefined;
    getDefaulStrokeColor(): Color | undefined;
    getStrokeGradient(): Gradient | undefined;
    getStrokeWeight(): number | undefined;
    /** The applied object style as a relation (Layer 1), resolved via the registry. */
    getAppliedObjectStyle(): import("../ObjectStyle.js").ObjectStyle | undefined;
    /**
     * Layer 2 — the effective surface style for this item: the applied object
     * style's resolved cascade, with this item's own local attributes overlaid
     * on top (local always wins). Every field is concrete, so consumers never
     * need to invent defaults like `?? 1` or `getColors()[0]`.
     *
     * Computed on demand (not cached) because sprites are mutable via the
     * setStrokeColor / setStrokeWeight / setFillColor setters.
     */
    getMergedStyle(): MergedObjectStyle;
    private static isNonePaint;
    private resolvePaint;
    /** Effective fill (color or gradient), or undefined for a `[None]` fill. */
    getEffectiveFill(): Color | Gradient | undefined;
    /**
     * Effective stroke (color or gradient), or undefined when the stroke is
     * `[None]` OR the effective weight is 0 (no visible stroke either way).
     */
    getEffectiveStroke(): Color | Gradient | undefined;
    /** Effective stroke weight in points (always concrete; 0 means no stroke). */
    getEffectiveStrokeWeight(): number;
    /**
     * Effective fill tint as a 0..100 percentage (100 = full color). IDML stores
     * `-1` / unset to mean "no tint"; both normalize to 100 here so consumers can
     * multiply unconditionally.
     */
    getEffectiveFillTint(): number;
    /** Effective stroke tint as a 0..100 percentage (100 = full color). */
    getEffectiveStrokeTint(): number;
    /**
     * Effective stroke alignment as the Bluepic value. Resolved through the full
     * cascade (local StrokeAlignment over the applied object style's, down to the
     * `[None]` default of CenterAlignment), then mapped to 'inside'|'center'|'outside'.
     */
    getEffectiveStrokeAlignment(): StrokeAlignment;
    setFillColor(color: ColorInput): void;
    setStrokeColor(color: ColorInput): void;
    setStrokeWeight(weight: number): void;
    getOpacity(): number;
    /** CSS mix-blend-mode from IDML `BlendMode` (PascalCase → kebab-case), or null for Normal. */
    getBlendMode(): string | null;
    setOpacity(opacity: number): void;
    getDropShadow(): {
        mode: string;
        xOffset: number;
        yOffset: number;
        size: number;
        effectColor: Color | undefined;
        spread: number;
        opacity: number;
    } | undefined;
    setDropShadow(dropShadow: DropShadowInput): void;
    getVisible(): boolean | undefined;
    /** InDesign "Nonprinting" attribute (Attributes panel) — such items export blank. */
    getNonprinting(): boolean;
    /** Should this item paint at all? Gates on Visible + Nonprinting (layer visibility TODO — layers
     * aren't modelled yet). Mirrors InDesign's export: invisible/nonprinting items produce nothing. */
    isRenderable(): boolean;
    setVisible(visible: boolean): void;
    getTransform(origin: [number, number]): Transform;
    setTranform(transform: Transform, origin: [number, number]): void;
    setTransformFromMatrix(matrix: TransformMatrix): void;
    serializeTransparencySetting(): import("../../util/xml.js").ElementNode | undefined;
    /** The XML tag to serialize as. Defaults to `type`; overridden by placed
     * graphics (PDF/EPS/WMF) parsed as ImageSprite to round-trip their real tag. */
    protected serializeTagName(): string;
    serializeSprite(): import("../../util/xml.js").ElementNode;
    static parseElementOptions(element: Element, context: IDMLSpreadPackageContext): SpriteOpts & {
        id: string;
    };
    static parseBlendingSetting(element: Element): {
        opacity: number;
        blendMode: string | undefined;
    };
    static parseDropShadowSetting(element: Element): {
        mode: "drop";
        xOffset: number;
        yOffset: number;
        size: number;
        effectColorId: string;
        spread: number;
        opacity: number;
    };
    static parseTransparencySetting(element: Element): {
        blendingSetting: {
            opacity: number;
            blendMode: string | undefined;
        } | undefined;
        dropShadowSetting: {
            mode: "drop";
            xOffset: number;
            yOffset: number;
            size: number;
            effectColorId: string;
            spread: number;
            opacity: number;
        } | undefined;
    };
}
//# sourceMappingURL=Sprite.d.ts.map