export type BlendMode = 'pass through' | 'normal' | 'dissolve' | 'darken' | 'multiply' | 'color burn' | 'linear burn' | 'darker color' | 'lighten' | 'screen' | 'color dodge' | 'linear dodge' | 'lighter color' | 'overlay' | 'soft light' | 'hard light' | 'vivid light' | 'linear light' | 'pin light' | 'hard mix' | 'difference' | 'exclusion' | 'subtract' | 'divide' | 'hue' | 'saturation' | 'color' | 'luminosity';
export declare const enum ColorMode {
    Bitmap = 0,
    Grayscale = 1,
    Indexed = 2,
    RGB = 3,
    CMYK = 4,
    Multichannel = 7,
    Duotone = 8,
    Lab = 9
}
export declare const enum SectionDividerType {
    Other = 0,
    OpenFolder = 1,
    ClosedFolder = 2,
    BoundingSectionDivider = 3
}
export type RGBA = {
    r: number;
    g: number;
    b: number;
    a: number;
};
export type RGB = {
    r: number;
    g: number;
    b: number;
};
export type FRGB = {
    fr: number;
    fg: number;
    fb: number;
};
export type HSB = {
    h: number;
    s: number;
    b: number;
};
export type CMYK = {
    c: number;
    m: number;
    y: number;
    k: number;
};
export type LAB = {
    l: number;
    a: number;
    b: number;
};
export type Grayscale = {
    k: number;
};
export type Color = RGBA | RGB | FRGB | HSB | CMYK | LAB | Grayscale;
export interface EffectContour {
    name: string;
    curve: {
        x: number;
        y: number;
    }[];
}
export interface EffectPattern {
    name: string;
    id: string;
}
export interface LayerEffectShadow {
    present?: boolean;
    showInDialog?: boolean;
    enabled?: boolean;
    size?: UnitsValue;
    angle?: number;
    distance?: UnitsValue;
    color?: Color;
    blendMode?: BlendMode;
    opacity?: number;
    useGlobalLight?: boolean;
    antialiased?: boolean;
    contour?: EffectContour;
    choke?: UnitsValue;
    layerConceals?: boolean;
}
export interface LayerEffectsOuterGlow {
    present?: boolean;
    showInDialog?: boolean;
    enabled?: boolean;
    size?: UnitsValue;
    color?: Color;
    blendMode?: BlendMode;
    opacity?: number;
    source?: GlowSource;
    antialiased?: boolean;
    noise?: number;
    range?: number;
    choke?: UnitsValue;
    jitter?: number;
    contour?: EffectContour;
}
export interface LayerEffectInnerGlow {
    present?: boolean;
    showInDialog?: boolean;
    enabled?: boolean;
    size?: UnitsValue;
    color?: Color;
    blendMode?: BlendMode;
    opacity?: number;
    source?: GlowSource;
    technique?: GlowTechnique;
    antialiased?: boolean;
    noise?: number;
    range?: number;
    choke?: UnitsValue;
    jitter?: number;
    contour?: EffectContour;
}
export interface LayerEffectBevel {
    present?: boolean;
    showInDialog?: boolean;
    enabled?: boolean;
    size?: UnitsValue;
    angle?: number;
    strength?: number;
    highlightBlendMode?: BlendMode;
    shadowBlendMode?: BlendMode;
    highlightColor?: Color;
    shadowColor?: Color;
    style?: BevelStyle;
    highlightOpacity?: number;
    shadowOpacity?: number;
    soften?: UnitsValue;
    useGlobalLight?: boolean;
    altitude?: number;
    technique?: BevelTechnique;
    direction?: BevelDirection;
    useTexture?: boolean;
    useShape?: boolean;
    antialiasGloss?: boolean;
    contour?: EffectContour;
}
export interface LayerEffectSolidFill {
    present?: boolean;
    showInDialog?: boolean;
    enabled?: boolean;
    blendMode?: BlendMode;
    color?: Color;
    opacity?: number;
}
export interface LayerEffectStroke {
    present?: boolean;
    showInDialog?: boolean;
    enabled?: boolean;
    overprint?: boolean;
    size?: UnitsValue;
    position?: 'inside' | 'center' | 'outside';
    fillType?: 'color' | 'gradient' | 'pattern';
    blendMode?: BlendMode;
    opacity?: number;
    color?: Color;
    gradient?: (EffectSolidGradient | EffectNoiseGradient) & ExtraGradientInfo;
    pattern?: EffectPattern & {};
}
export interface LayerEffectSatin {
    present?: boolean;
    showInDialog?: boolean;
    enabled?: boolean;
    size?: UnitsValue;
    blendMode?: BlendMode;
    color?: Color;
    antialiased?: boolean;
    opacity?: number;
    distance?: UnitsValue;
    invert?: boolean;
    angle?: number;
    contour?: EffectContour;
}
export interface LayerEffectPatternOverlay {
    present?: boolean;
    showInDialog?: boolean;
    enabled?: boolean;
    blendMode?: BlendMode;
    opacity?: number;
    scale?: number;
    pattern?: EffectPattern;
    phase?: {
        x: number;
        y: number;
    };
    align?: boolean;
}
export interface EffectSolidGradient {
    name: string;
    type: 'solid';
    smoothness?: number;
    colorStops: ColorStop[];
    opacityStops: OpacityStop[];
}
export interface EffectNoiseGradient {
    name: string;
    type: 'noise';
    roughness?: number;
    colorModel?: 'rgb' | 'hsb' | 'lab';
    randomSeed?: number;
    restrictColors?: boolean;
    addTransparency?: boolean;
    min: number[];
    max: number[];
}
export interface LayerEffectGradientOverlay {
    present?: boolean;
    showInDialog?: boolean;
    enabled?: boolean;
    blendMode?: string;
    opacity?: number;
    align?: boolean;
    scale?: number;
    dither?: boolean;
    reverse?: boolean;
    type?: GradientStyle;
    offset?: {
        x: number;
        y: number;
    };
    gradient?: EffectSolidGradient | EffectNoiseGradient;
    interpolationMethod?: InterpolationMethod;
    angle?: number;
}
export interface LayerEffectsInfo {
    disabled?: boolean;
    scale?: number;
    dropShadow?: LayerEffectShadow[];
    innerShadow?: LayerEffectShadow[];
    outerGlow?: LayerEffectsOuterGlow;
    innerGlow?: LayerEffectInnerGlow;
    bevel?: LayerEffectBevel;
    solidFill?: LayerEffectSolidFill[];
    satin?: LayerEffectSatin;
    stroke?: LayerEffectStroke[];
    gradientOverlay?: LayerEffectGradientOverlay[];
    patternOverlay?: LayerEffectPatternOverlay;
}
export type PixelArray = Uint8ClampedArray | Uint8Array | Uint16Array | Float32Array;
export interface PixelData {
    data: PixelArray;
    width: number;
    height: number;
}
export interface LayerMaskData {
    top?: number;
    left?: number;
    bottom?: number;
    right?: number;
    defaultColor?: number;
    disabled?: boolean;
    positionRelativeToLayer?: boolean;
    fromVectorData?: boolean;
    userMaskDensity?: number;
    userMaskFeather?: number;
    vectorMaskDensity?: number;
    vectorMaskFeather?: number;
    canvas?: HTMLCanvasElement;
    imageData?: PixelData;
}
export type TextGridding = 'none' | 'round';
export type Orientation = 'horizontal' | 'vertical';
export type AntiAlias = 'none' | 'sharp' | 'crisp' | 'strong' | 'smooth' | 'platform' | 'platformLCD';
export type WarpStyle = 'none' | 'arc' | 'arcLower' | 'arcUpper' | 'arch' | 'bulge' | 'shellLower' | 'shellUpper' | 'flag' | 'wave' | 'fish' | 'rise' | 'fisheye' | 'inflate' | 'squeeze' | 'twist' | 'custom' | 'cylinder';
export type BevelStyle = 'outer bevel' | 'inner bevel' | 'emboss' | 'pillow emboss' | 'stroke emboss';
export type BevelTechnique = 'smooth' | 'chisel hard' | 'chisel soft';
export type BevelDirection = 'up' | 'down';
export type GlowTechnique = 'softer' | 'precise';
export type GlowSource = 'edge' | 'center';
export type GradientStyle = 'linear' | 'radial' | 'angle' | 'reflected' | 'diamond';
export type Justification = 'left' | 'right' | 'center' | 'justify-left' | 'justify-right' | 'justify-center' | 'justify-all';
export type LineCapType = 'butt' | 'round' | 'square';
export type LineJoinType = 'miter' | 'round' | 'bevel';
export type LineAlignment = 'inside' | 'center' | 'outside';
export type InterpolationMethod = 'classic' | 'perceptual' | 'linear' | 'smooth';
export interface Warp {
    style?: WarpStyle;
    value?: number;
    values?: number[];
    perspective?: number;
    perspectiveOther?: number;
    rotate?: Orientation;
    bounds?: {
        top: UnitsValue;
        left: UnitsValue;
        bottom: UnitsValue;
        right: UnitsValue;
    };
    uOrder?: number;
    vOrder?: number;
    deformNumRows?: number;
    deformNumCols?: number;
    customEnvelopeWarp?: {
        quiltSliceX?: number[];
        quiltSliceY?: number[];
        meshPoints: {
            x: number;
            y: number;
        }[];
    };
}
export interface Animations {
    frames: {
        id: number;
        delay: number;
        dispose?: 'auto' | 'none' | 'dispose';
    }[];
    animations: {
        id: number;
        frames: number[];
        repeats?: number;
        activeFrame?: number;
    }[];
}
export interface Font {
    name: string;
    script?: number;
    type?: number;
    synthetic?: number;
}
export interface ParagraphStyle {
    justification?: Justification;
    firstLineIndent?: number;
    startIndent?: number;
    endIndent?: number;
    spaceBefore?: number;
    spaceAfter?: number;
    autoHyphenate?: boolean;
    hyphenatedWordSize?: number;
    preHyphen?: number;
    postHyphen?: number;
    consecutiveHyphens?: number;
    zone?: number;
    wordSpacing?: number[];
    letterSpacing?: number[];
    glyphSpacing?: number[];
    autoLeading?: number;
    leadingType?: number;
    hanging?: boolean;
    burasagari?: boolean;
    kinsokuOrder?: number;
    everyLineComposer?: boolean;
}
export interface ParagraphStyleRun {
    length: number;
    style: ParagraphStyle;
}
export interface TextStyle {
    font?: Font;
    fontSize?: number;
    fauxBold?: boolean;
    fauxItalic?: boolean;
    autoLeading?: boolean;
    leading?: number;
    horizontalScale?: number;
    verticalScale?: number;
    tracking?: number;
    autoKerning?: boolean;
    kerning?: number;
    baselineShift?: number;
    fontCaps?: number;
    fontBaseline?: number;
    underline?: boolean;
    strikethrough?: boolean;
    ligatures?: boolean;
    dLigatures?: boolean;
    baselineDirection?: number;
    tsume?: number;
    styleRunAlignment?: number;
    language?: number;
    noBreak?: boolean;
    fillColor?: Color;
    strokeColor?: Color;
    fillFlag?: boolean;
    strokeFlag?: boolean;
    fillFirst?: boolean;
    yUnderline?: number;
    outlineWidth?: number;
    characterDirection?: number;
    hindiNumbers?: boolean;
    kashida?: number;
    diacriticPos?: number;
}
export interface TextStyleRun {
    length: number;
    style: TextStyle;
}
export interface TextGridInfo {
    isOn?: boolean;
    show?: boolean;
    size?: number;
    leading?: number;
    color?: Color;
    leadingFillColor?: Color;
    alignLineHeightToGridFlags?: boolean;
}
export interface UnitsBounds {
    top: UnitsValue;
    left: UnitsValue;
    right: UnitsValue;
    bottom: UnitsValue;
}
export interface TextPath {
    name?: number[];
    bezierCurve?: {
        controlPoints: number[];
    };
    data: {
        type?: number;
        orientation?: number;
        frameMatrix: number[];
        textRange: number[];
        rowGutter?: number;
        columnGutter?: number;
        BaselineAlignment?: {
            flag?: number;
            min?: number;
        };
        pathData: {
            reversed?: boolean;
            spacing?: number;
        };
    };
    uuid?: string;
}
export interface LayerTextData {
    text: string;
    transform?: number[];
    antiAlias?: AntiAlias;
    gridding?: TextGridding;
    orientation?: Orientation;
    index?: number;
    warp?: Warp;
    top?: number;
    left?: number;
    bottom?: number;
    right?: number;
    gridInfo?: TextGridInfo;
    useFractionalGlyphWidths?: boolean;
    style?: TextStyle;
    styleRuns?: TextStyleRun[];
    paragraphStyle?: ParagraphStyle;
    paragraphStyleRuns?: ParagraphStyleRun[];
    superscriptSize?: number;
    superscriptPosition?: number;
    subscriptSize?: number;
    subscriptPosition?: number;
    smallCapSize?: number;
    shapeType?: 'point' | 'box';
    pointBase?: number[];
    boxBounds?: number[];
    bounds?: UnitsBounds;
    boundingBox?: UnitsBounds;
    /** This is read-only field, any changes will not be saved */
    textPath?: TextPath;
}
export interface PatternInfo {
    name: string;
    id: string;
    x: number;
    y: number;
    bounds: {
        x: number;
        y: number;
        w: number;
        h: number;
    };
    data: Uint8Array;
}
export interface BezierKnot {
    linked: boolean;
    points: number[];
}
export type BooleanOperation = 'exclude' | 'combine' | 'subtract' | 'intersect';
export interface BezierPath {
    open: boolean;
    operation?: BooleanOperation;
    knots: BezierKnot[];
    fillRule: 'even-odd' | 'non-zero';
}
export interface ExtraGradientInfo {
    style?: GradientStyle;
    scale?: number;
    angle?: number;
    dither?: boolean;
    interpolationMethod?: InterpolationMethod;
    reverse?: boolean;
    align?: boolean;
    offset?: {
        x: number;
        y: number;
    };
}
export interface ExtraPatternInfo {
    linked?: boolean;
    phase?: {
        x: number;
        y: number;
    };
}
export type VectorContent = {
    type: 'color';
    color: Color;
} | (EffectSolidGradient & ExtraGradientInfo) | (EffectNoiseGradient & ExtraGradientInfo) | (EffectPattern & {
    type: 'pattern';
} & ExtraPatternInfo);
export type RenderingIntent = 'perceptual' | 'saturation' | 'relative colorimetric' | 'absolute colorimetric';
export type Units = 'Pixels' | 'Points' | 'Picas' | 'Millimeters' | 'Centimeters' | 'Inches' | 'None' | 'Density';
export interface UnitsValue {
    units: Units;
    value: number;
}
export interface BrightnessAdjustment {
    type: 'brightness/contrast';
    brightness?: number;
    contrast?: number;
    meanValue?: number;
    useLegacy?: boolean;
    labColorOnly?: boolean;
    auto?: boolean;
}
export interface LevelsAdjustmentChannel {
    shadowInput: number;
    highlightInput: number;
    shadowOutput: number;
    highlightOutput: number;
    midtoneInput: number;
}
export interface PresetInfo {
    presetKind?: number;
    presetFileName?: string;
}
export interface LevelsAdjustment extends PresetInfo {
    type: 'levels';
    rgb?: LevelsAdjustmentChannel;
    red?: LevelsAdjustmentChannel;
    green?: LevelsAdjustmentChannel;
    blue?: LevelsAdjustmentChannel;
}
export type CurvesAdjustmentChannel = {
    input: number;
    output: number;
}[];
export interface CurvesAdjustment extends PresetInfo {
    type: 'curves';
    rgb?: CurvesAdjustmentChannel;
    red?: CurvesAdjustmentChannel;
    green?: CurvesAdjustmentChannel;
    blue?: CurvesAdjustmentChannel;
}
export interface ExposureAdjustment extends PresetInfo {
    type: 'exposure';
    exposure?: number;
    offset?: number;
    gamma?: number;
}
export interface VibranceAdjustment {
    type: 'vibrance';
    vibrance?: number;
    saturation?: number;
}
export interface HueSaturationAdjustmentChannel {
    a: number;
    b: number;
    c: number;
    d: number;
    hue: number;
    saturation: number;
    lightness: number;
}
export interface HueSaturationAdjustment extends PresetInfo {
    type: 'hue/saturation';
    master?: HueSaturationAdjustmentChannel;
    reds?: HueSaturationAdjustmentChannel;
    yellows?: HueSaturationAdjustmentChannel;
    greens?: HueSaturationAdjustmentChannel;
    cyans?: HueSaturationAdjustmentChannel;
    blues?: HueSaturationAdjustmentChannel;
    magentas?: HueSaturationAdjustmentChannel;
}
export interface ColorBalanceValues {
    cyanRed: number;
    magentaGreen: number;
    yellowBlue: number;
}
export interface ColorBalanceAdjustment {
    type: 'color balance';
    shadows?: ColorBalanceValues;
    midtones?: ColorBalanceValues;
    highlights?: ColorBalanceValues;
    preserveLuminosity?: boolean;
}
export interface BlackAndWhiteAdjustment extends PresetInfo {
    type: 'black & white';
    reds?: number;
    yellows?: number;
    greens?: number;
    cyans?: number;
    blues?: number;
    magentas?: number;
    useTint?: boolean;
    tintColor?: Color;
}
export interface PhotoFilterAdjustment {
    type: 'photo filter';
    color?: Color;
    density?: number;
    preserveLuminosity?: boolean;
}
export interface ChannelMixerChannel {
    red: number;
    green: number;
    blue: number;
    constant: number;
}
export interface ChannelMixerAdjustment extends PresetInfo {
    type: 'channel mixer';
    monochrome?: boolean;
    red?: ChannelMixerChannel;
    green?: ChannelMixerChannel;
    blue?: ChannelMixerChannel;
    gray?: ChannelMixerChannel;
}
export interface ColorLookupAdjustment {
    type: 'color lookup';
    lookupType?: '3dlut' | 'abstractProfile' | 'deviceLinkProfile';
    name?: string;
    dither?: boolean;
    profile?: Uint8Array;
    lutFormat?: 'look' | 'cube' | '3dl';
    dataOrder?: 'rgb' | 'bgr';
    tableOrder?: 'rgb' | 'bgr';
    lut3DFileData?: Uint8Array;
    lut3DFileName?: string;
}
export interface InvertAdjustment {
    type: 'invert';
}
export interface PosterizeAdjustment {
    type: 'posterize';
    levels?: number;
}
export interface ThresholdAdjustment {
    type: 'threshold';
    level?: number;
}
export interface ColorStop {
    color: Color;
    location: number;
    midpoint: number;
}
export interface OpacityStop {
    opacity: number;
    location: number;
    midpoint: number;
}
export interface GradientMapAdjustment {
    type: 'gradient map';
    name?: string;
    gradientType: 'solid' | 'noise';
    dither?: boolean;
    reverse?: boolean;
    method?: InterpolationMethod;
    smoothness?: number;
    colorStops?: ColorStop[];
    opacityStops?: OpacityStop[];
    roughness?: number;
    colorModel?: 'rgb' | 'hsb' | 'lab';
    randomSeed?: number;
    restrictColors?: boolean;
    addTransparency?: boolean;
    min?: number[];
    max?: number[];
}
export interface SelectiveColorAdjustment {
    type: 'selective color';
    mode?: 'relative' | 'absolute';
    reds?: CMYK;
    yellows?: CMYK;
    greens?: CMYK;
    cyans?: CMYK;
    blues?: CMYK;
    magentas?: CMYK;
    whites?: CMYK;
    neutrals?: CMYK;
    blacks?: CMYK;
}
export type LinkedFile = {
    id: string;
    name: string;
    type?: string;
    creator?: string;
    data?: Uint8Array;
    time?: string;
    descriptor?: {
        compInfo: {
            compID: number;
            originalCompID: number;
        };
    };
    childDocumentID?: string;
    assetModTime?: number;
    assetLockedState?: number;
    linkedFile?: {
        fileSize: number;
        name: string;
        fullPath: string;
        originalPath: string;
        relativePath: string;
    };
};
type FilterVariant = {
    type: 'average' | 'blur' | 'blur more';
} | {
    type: 'box blur';
    filter: {
        radius: UnitsValue;
    };
} | {
    type: 'gaussian blur';
    filter: {
        radius: UnitsValue;
    };
} | {
    type: 'motion blur';
    filter: {
        angle: number;
        distance: UnitsValue;
    };
} | {
    type: 'radial blur';
    filter: {
        amount: number;
        method: 'spin' | 'zoom';
        quality: 'draft' | 'good' | 'best';
    };
} | {
    type: 'shape blur';
    filter: {
        radius: UnitsValue;
        customShape: {
            name: string;
            id: string;
        };
    };
} | {
    type: 'smart blur';
    filter: {
        radius: number;
        threshold: number;
        quality: 'low' | 'medium' | 'high';
        mode: 'normal' | 'edge only' | 'overlay edge';
    };
} | {
    type: 'surface blur';
    filter: {
        radius: UnitsValue;
        threshold: number;
    };
} | {
    type: 'displace';
    filter: {
        horizontalScale: number;
        verticalScale: number;
        displacementMap: 'stretch to fit' | 'tile';
        undefinedAreas: 'wrap around' | 'repeat edge pixels';
        displacementFile: {
            signature: string;
            path: string;
        };
    };
} | {
    type: 'pinch';
    filter: {
        amount: number;
    };
} | {
    type: 'polar coordinates';
    filter: {
        conversion: 'rectangular to polar' | 'polar to rectangular';
    };
} | {
    type: 'ripple';
    filter: {
        amount: number;
        size: 'small' | 'medium' | 'large';
    };
} | {
    type: 'shear';
    filter: {
        shearPoints: {
            x: number;
            y: number;
        }[];
        shearStart: number;
        shearEnd: number;
        undefinedAreas: 'wrap around' | 'repeat edge pixels';
    };
} | {
    type: 'spherize';
    filter: {
        amount: number;
        mode: 'normal' | 'horizontal only' | 'vertical only';
    };
} | {
    type: 'twirl';
    filter: {
        angle: number;
    };
} | {
    type: 'wave';
    filter: {
        numberOfGenerators: number;
        type: 'sine' | 'triangle' | 'square';
        wavelength: {
            min: number;
            max: number;
        };
        amplitude: {
            min: number;
            max: number;
        };
        scale: {
            x: number;
            y: number;
        };
        randomSeed: number;
        undefinedAreas: 'wrap around' | 'repeat edge pixels';
    };
} | {
    type: 'zigzag';
    filter: {
        amount: number;
        ridges: number;
        style: 'around center' | 'out from center' | 'pond ripples';
    };
} | {
    type: 'add noise';
    filter: {
        amount: number;
        distribution: 'uniform' | 'gaussian';
        monochromatic: boolean;
        randomSeed: number;
    };
} | {
    type: 'despeckle';
} | {
    type: 'dust and scratches';
    filter: {
        radius: number;
        threshold: number;
    };
} | {
    type: 'median';
    filter: {
        radius: UnitsValue;
    };
} | {
    type: 'reduce noise';
    filter: {
        preset: string;
        removeJpegArtifact: boolean;
        reduceColorNoise: number;
        sharpenDetails: number;
        channelDenoise: {
            channels: ('red' | 'green' | 'blue' | 'composite')[];
            amount: number;
            preserveDetails?: number;
        }[];
    };
} | {
    type: 'color halftone';
    filter: {
        radius: number;
        angle1: number;
        angle2: number;
        angle3: number;
        angle4: number;
    };
} | {
    type: 'crystallize';
    filter: {
        cellSize: number;
        randomSeed: number;
    };
} | {
    type: 'facet' | 'fragment';
} | {
    type: 'mezzotint';
    filter: {
        type: 'fine dots' | 'medium dots' | 'grainy dots' | 'coarse dots' | 'short lines' | 'medium lines' | 'long lines' | 'short strokes' | 'medium strokes' | 'long strokes';
        randomSeed: number;
    };
} | {
    type: 'mosaic';
    filter: {
        cellSize: UnitsValue;
    };
} | {
    type: 'pointillize';
    filter: {
        cellSize: number;
        randomSeed: number;
    };
} | {
    type: 'clouds';
    filter: {
        randomSeed: number;
    };
} | {
    type: 'difference clouds';
    filter: {
        randomSeed: number;
    };
} | {
    type: 'fibers';
    filter: {
        variance: number;
        strength: number;
        randomSeed: number;
    };
} | {
    type: 'lens flare';
    filter: {
        brightness: number;
        position: {
            x: number;
            y: number;
        };
        lensType: '50-300mm zoom' | '32mm prime' | '105mm prime' | 'movie prime';
    };
} | {
    type: 'sharpen' | 'sharpen edges' | 'sharpen more';
} | {
    type: 'smart sharpen';
    filter: {
        amount: number;
        radius: UnitsValue;
        threshold: number;
        angle: number;
        moreAccurate: boolean;
        blur: 'gaussian blur' | 'lens blur' | 'motion blur';
        preset: string;
        shadow: {
            fadeAmount: number;
            tonalWidth: number;
            radius: number;
        };
        highlight: {
            fadeAmount: number;
            tonalWidth: number;
            radius: number;
        };
    };
} | {
    type: 'unsharp mask';
    filter: {
        amount: number;
        radius: UnitsValue;
        threshold: number;
    };
} | {
    type: 'diffuse';
    filter: {
        mode: 'normal' | 'darken only' | 'lighten only' | 'anisotropic';
        randomSeed: number;
    };
} | {
    type: 'emboss';
    filter: {
        angle: number;
        height: number;
        amount: number;
    };
} | {
    type: 'extrude';
    filter: {
        type: 'blocks' | 'pyramids';
        size: number;
        depth: number;
        depthMode: 'random' | 'level-based';
        randomSeed: number;
        solidFrontFaces: boolean;
        maskIncompleteBlocks: boolean;
    };
} | {
    type: 'find edges' | 'solarize';
} | {
    type: 'tiles';
    filter: {
        numberOfTiles: number;
        maximumOffset: number;
        fillEmptyAreaWith: 'background color' | 'foreground color' | 'inverse image' | 'unaltered image';
        randomSeed: number;
    };
} | {
    type: 'trace contour';
    filter: {
        level: number;
        edge: 'lower' | 'upper';
    };
} | {
    type: 'wind';
    filter: {
        method: 'wind' | 'blast' | 'stagger';
        direction: 'left' | 'right';
    };
} | {
    type: 'de-interlace';
    filter: {
        eliminate: 'odd lines' | 'even lines';
        newFieldsBy: 'duplication' | 'interpolation';
    };
} | {
    type: 'ntsc colors';
} | {
    type: 'custom';
    filter: {
        scale: number;
        offset: number;
        matrix: number[];
    };
} | {
    type: 'high pass' | 'maximum' | 'minimum';
    filter: {
        radius: UnitsValue;
    };
} | {
    type: 'offset';
    filter: {
        horizontal: number;
        vertical: number;
        undefinedAreas: 'set to transparent' | 'repeat edge pixels' | 'wrap around';
    };
} | {
    type: 'puppet';
    filter: {
        rigidType: boolean;
        bounds: {
            x: number;
            y: number;
        }[];
        puppetShapeList: {
            rigidType: boolean;
            originalVertexArray: {
                x: number;
                y: number;
            }[];
            deformedVertexArray: {
                x: number;
                y: number;
            }[];
            indexArray: number[];
            pinOffsets: {
                x: number;
                y: number;
            }[];
            posFinalPins: {
                x: number;
                y: number;
            }[];
            pinVertexIndices: number[];
            selectedPin: number[];
            pinPosition: {
                x: number;
                y: number;
            }[];
            pinRotation: number[];
            pinOverlay: boolean[];
            pinDepth: number[];
            meshQuality: number;
            meshExpansion: number;
            meshRigidity: number;
            imageResolution: number;
            meshBoundaryPath: {
                pathComponents: {
                    shapeOperation: string;
                    paths: {
                        closed: boolean;
                        points: {
                            anchor: {
                                x: UnitsValue;
                                y: UnitsValue;
                            };
                            forward: {
                                x: UnitsValue;
                                y: UnitsValue;
                            };
                            backward: {
                                x: UnitsValue;
                                y: UnitsValue;
                            };
                            smooth: boolean;
                        }[];
                    }[];
                }[];
            };
        }[];
    };
} | {
    type: 'oil paint plugin';
    filter: {
        name: string;
        gpu: boolean;
        lighting: boolean;
        parameters: {
            name: string;
            value: number;
        }[];
    };
} | {
    type: 'hsb/hsl';
    filter: {
        inputMode: 'rgb' | 'hsb' | 'hsl';
        rowOrder: 'rgb' | 'hsb' | 'hsl';
    };
} | {
    type: 'oil paint';
    filter: {
        lightingOn: boolean;
        stylization: number;
        cleanliness: number;
        brushScale: number;
        microBrush: number;
        lightDirection: number;
        specularity: number;
    };
} | {
    type: 'liquify';
    filter: {
        liquifyMesh: Uint8Array;
    };
} | {
    type: 'perspective warp';
    filter: {
        quads: number[][];
        vertices: {
            x: UnitsValue;
            y: UnitsValue;
        }[];
        warpedVertices: {
            x: UnitsValue;
            y: UnitsValue;
        }[];
    };
} | {
    type: 'curves';
    filter: {
        presetKind: 'custom' | 'default';
        adjustments?: ({
            channels: ('composite' | 'red' | 'green' | 'blue')[];
            curve: {
                x: number;
                y: number;
                curved?: boolean;
            }[];
        } | {
            channels: ('composite' | 'red' | 'green' | 'blue')[];
            values: number[];
        })[];
    };
} | {
    type: 'invert';
} | {
    type: 'brightness/contrast';
    filter: {
        brightness: number;
        contrast: number;
        useLegacy: boolean;
    };
};
export type Filter = FilterVariant & {
    name: string;
    opacity: number;
    blendMode: BlendMode;
    enabled: boolean;
    hasOptions: boolean;
    foregroundColor: Color;
    backgroundColor: Color;
};
export interface PlacedLayerFilter {
    enabled: boolean;
    validAtPosition: boolean;
    maskEnabled: boolean;
    maskLinked: boolean;
    maskExtendWithWhite: boolean;
    list: Filter[];
}
export type PlacedLayerType = 'unknown' | 'vector' | 'raster' | 'image stack';
export interface PlacedLayer {
    id: string;
    placed?: string;
    type: PlacedLayerType;
    pageNumber?: number;
    totalPages?: number;
    frameStep?: {
        numerator: number;
        denominator: number;
    };
    duration?: {
        numerator: number;
        denominator: number;
    };
    frameCount?: number;
    transform: number[];
    nonAffineTransform?: number[];
    width?: number;
    height?: number;
    resolution?: UnitsValue;
    warp?: Warp;
    crop?: number;
    comp?: number;
    compInfo?: {
        compID: number;
        originalCompID: number;
    };
    filter?: PlacedLayerFilter;
}
export type AdjustmentLayer = BrightnessAdjustment | LevelsAdjustment | CurvesAdjustment | ExposureAdjustment | VibranceAdjustment | HueSaturationAdjustment | ColorBalanceAdjustment | BlackAndWhiteAdjustment | PhotoFilterAdjustment | ChannelMixerAdjustment | ColorLookupAdjustment | InvertAdjustment | PosterizeAdjustment | ThresholdAdjustment | GradientMapAdjustment | SelectiveColorAdjustment;
export type LayerColor = 'none' | 'red' | 'orange' | 'yellow' | 'green' | 'blue' | 'violet' | 'gray';
export interface KeyDescriptorItem {
    keyShapeInvalidated?: boolean;
    keyOriginType?: number;
    keyOriginResolution?: number;
    keyOriginRRectRadii?: {
        topRight: UnitsValue;
        topLeft: UnitsValue;
        bottomLeft: UnitsValue;
        bottomRight: UnitsValue;
    };
    keyOriginShapeBoundingBox?: {
        top: UnitsValue;
        left: UnitsValue;
        bottom: UnitsValue;
        right: UnitsValue;
    };
    keyOriginBoxCorners?: {
        x: number;
        y: number;
    }[];
    transform?: number[];
}
export interface LayerVectorMask {
    invert?: boolean;
    notLink?: boolean;
    disable?: boolean;
    fillStartsWithAllPixels?: boolean;
    clipboard?: {
        top: number;
        left: number;
        bottom: number;
        right: number;
        resolution: number;
    };
    paths: BezierPath[];
}
export interface AnimationFrame {
    frames: number[];
    enable?: boolean;
    offset?: {
        x: number;
        y: number;
    };
    referencePoint?: {
        x: number;
        y: number;
    };
    opacity?: number;
    effects?: LayerEffectsInfo;
}
export interface Fraction {
    numerator: number;
    denominator: number;
}
export type TimelineKeyInterpolation = 'linear' | 'hold';
export type TimelineKey = {
    interpolation: TimelineKeyInterpolation;
    time: Fraction;
    selected?: boolean;
} & ({
    type: 'opacity';
    value: number;
} | {
    type: 'position';
    x: number;
    y: number;
} | {
    type: 'transform';
    scale: {
        x: number;
        y: number;
    };
    skew: {
        x: number;
        y: number;
    };
    rotation: number;
    translation: {
        x: number;
        y: number;
    };
} | {
    type: 'style';
    style?: LayerEffectsInfo;
} | {
    type: 'globalLighting';
    globalAngle: number;
    globalAltitude: number;
});
export type TimelineTrackType = 'opacity' | 'style' | 'sheetTransform' | 'sheetPosition' | 'globalLighting';
export interface TimelineTrack {
    type: TimelineTrackType;
    enabled?: boolean;
    effectParams?: {
        keys: TimelineKey[];
        fillCanvas: boolean;
        zoomOrigin: number;
    };
    keys: TimelineKey[];
}
export interface Timeline {
    start: Fraction;
    duration: Fraction;
    inTime: Fraction;
    outTime: Fraction;
    autoScope: boolean;
    audioLevel: number;
    tracks?: TimelineTrack[];
}
export interface LayerAdditionalInfo {
    name?: string;
    nameSource?: string;
    id?: number;
    version?: number;
    mask?: LayerMaskData;
    realMask?: LayerMaskData;
    blendClippendElements?: boolean;
    blendInteriorElements?: boolean;
    knockout?: boolean;
    layerMaskAsGlobalMask?: boolean;
    protected?: {
        transparency?: boolean;
        composite?: boolean;
        position?: boolean;
        artboards?: boolean;
    };
    layerColor?: LayerColor;
    referencePoint?: {
        x: number;
        y: number;
    };
    sectionDivider?: {
        type: SectionDividerType;
        key?: string;
        subType?: number;
    };
    filterMask?: {
        colorSpace: Color;
        opacity: number;
    };
    effects?: LayerEffectsInfo;
    text?: LayerTextData;
    patterns?: PatternInfo[];
    vectorFill?: VectorContent;
    vectorStroke?: {
        strokeEnabled?: boolean;
        fillEnabled?: boolean;
        lineWidth?: UnitsValue;
        lineDashOffset?: UnitsValue;
        miterLimit?: number;
        lineCapType?: LineCapType;
        lineJoinType?: LineJoinType;
        lineAlignment?: LineAlignment;
        scaleLock?: boolean;
        strokeAdjust?: boolean;
        lineDashSet?: UnitsValue[];
        blendMode?: BlendMode;
        opacity?: number;
        content?: VectorContent;
        resolution?: number;
    };
    vectorMask?: LayerVectorMask;
    usingAlignedRendering?: boolean;
    timestamp?: number;
    pathList?: {}[];
    adjustment?: AdjustmentLayer;
    placedLayer?: PlacedLayer;
    vectorOrigination?: {
        keyDescriptorList: KeyDescriptorItem[];
    };
    compositorUsed?: {
        version?: {
            major: number;
            minor: number;
            fix: number;
        };
        photoshopVersion?: {
            major: number;
            minor: number;
            fix: number;
        };
        description: string;
        reason: string;
        engine: string;
        enableCompCore?: string;
        enableCompCoreGPU?: string;
        enableCompCoreThreads?: string;
        compCoreSupport?: string;
        compCoreGPUSupport?: string;
    };
    artboard?: {
        rect: {
            top: number;
            left: number;
            bottom: number;
            right: number;
        };
        guideIndices?: any[];
        presetName?: string;
        color?: Color;
        backgroundType?: number;
    };
    fillOpacity?: number;
    transparencyShapesLayer?: boolean;
    channelBlendingRestrictions?: number[];
    animationFrames?: AnimationFrame[];
    animationFrameFlags?: {
        propagateFrameOne?: boolean;
        unifyLayerPosition?: boolean;
        unifyLayerStyle?: boolean;
        unifyLayerVisibility?: boolean;
    };
    timeline?: Timeline;
    filterEffectsMasks?: {
        id: string;
        top: number;
        left: number;
        bottom: number;
        right: number;
        depth: number;
        channels: ({
            compressionMode: number;
            data: Uint8Array;
        } | undefined)[];
        extra?: {
            top: number;
            left: number;
            bottom: number;
            right: number;
            compressionMode: number;
            data: Uint8Array;
        };
    }[];
    comps?: {
        originalEffectsReferencePoint?: {
            x: number;
            y: number;
        };
        settings: {
            enabled?: boolean;
            compList: number[];
            offset?: {
                x: number;
                y: number;
            };
            effectsReferencePoint?: {
                x: number;
                y: number;
            };
        }[];
    };
    userMask?: {
        colorSpace: Color;
        opacity: number;
    };
    blendingRanges?: {
        compositeGrayBlendSource: number[];
        compositeGraphBlendDestinationRange: number[];
        ranges: {
            sourceRange: number[];
            destRange: number[];
        }[];
    };
    vowv?: number;
    pixelSource?: {
        type: 'vdPS';
        origin: {
            x: number;
            y: number;
        };
        interpretation: {
            interpretAlpha: string;
            profile: Uint8Array;
        };
        frameReader: {
            type: 'QTFR';
            link: {
                name: string;
                fullPath: string;
                originalPath: string;
                relativePath: string;
                alias: string;
            };
            mediaDescriptor: string;
        };
        showAlteredVideo: boolean;
    };
    engineData?: string;
}
export declare enum LayerCompCapturedInfo {
    None = 0,
    Visibility = 1,
    Position = 2,
    Appearance = 4
}
export interface ImageResources {
    layerState?: number;
    layerSelectionIds?: number[];
    versionInfo?: {
        hasRealMergedData: boolean;
        writerName: string;
        readerName: string;
        fileVersion: number;
    };
    alphaIdentifiers?: number[];
    alphaChannelNames?: string[];
    globalAngle?: number;
    globalAltitude?: number;
    pixelAspectRatio?: {
        aspect: number;
    };
    urlsList?: {
        id: number;
        ref: 'slice';
        url: string;
    }[];
    gridAndGuidesInformation?: {
        grid?: {
            horizontal: number;
            vertical: number;
        };
        guides?: {
            location: number;
            direction: 'horizontal' | 'vertical';
        }[];
    };
    resolutionInfo?: {
        horizontalResolution: number;
        horizontalResolutionUnit: 'PPI' | 'PPCM';
        widthUnit: 'Inches' | 'Centimeters' | 'Points' | 'Picas' | 'Columns';
        verticalResolution: number;
        verticalResolutionUnit: 'PPI' | 'PPCM';
        heightUnit: 'Inches' | 'Centimeters' | 'Points' | 'Picas' | 'Columns';
    };
    thumbnail?: HTMLCanvasElement;
    thumbnailRaw?: {
        width: number;
        height: number;
        data: Uint8Array;
    };
    captionDigest?: string;
    xmpMetadata?: string;
    printScale?: {
        style?: 'centered' | 'size to fit' | 'user defined';
        x?: number;
        y?: number;
        scale?: number;
    };
    printInformation?: {
        printerManagesColors?: boolean;
        printerName?: string;
        printerProfile?: string;
        printSixteenBit?: boolean;
        renderingIntent?: RenderingIntent;
        hardProof?: boolean;
        blackPointCompensation?: boolean;
        proofSetup?: {
            builtin: string;
        } | {
            profile: string;
            renderingIntent?: RenderingIntent;
            blackPointCompensation?: boolean;
            paperWhite?: boolean;
        };
    };
    backgroundColor?: Color;
    idsSeedNumber?: number;
    printFlags?: {
        labels?: boolean;
        cropMarks?: boolean;
        colorBars?: boolean;
        registrationMarks?: boolean;
        negative?: boolean;
        flip?: boolean;
        interpolate?: boolean;
        caption?: boolean;
        printFlags?: boolean;
    };
    iccUntaggedProfile?: boolean;
    pathSelectionState?: string[];
    imageReadyVariables?: string;
    imageReadyDataSets?: string;
    animations?: Animations;
    onionSkins?: {
        enabled: boolean;
        framesBefore: number;
        framesAfter: number;
        frameSpacing: number;
        minOpacity: number;
        maxOpacity: number;
        blendMode: BlendMode;
    };
    timelineInformation?: {
        enabled: boolean;
        frameStep: Fraction;
        frameRate: number;
        time: Fraction;
        duration: Fraction;
        workInTime: Fraction;
        workOutTime: Fraction;
        repeats: number;
        hasMotion: boolean;
        globalTracks: TimelineTrack[];
        audioClipGroups?: {
            id: string;
            muted: boolean;
            audioClips: {
                id: string;
                start: Fraction;
                duration: Fraction;
                inTime: Fraction;
                outTime: Fraction;
                muted: boolean;
                audioLevel: number;
                frameReader: {
                    type: number;
                    mediaDescriptor: string;
                    link: {
                        name: string;
                        fullPath: string;
                        relativePath: string;
                    };
                };
            }[];
        }[];
    };
    sheetDisclosure?: {
        sheetTimelineOptions?: {
            sheetID: number;
            sheetDisclosed: boolean;
            lightsDisclosed: boolean;
            meshesDisclosed: boolean;
            materialsDisclosed: boolean;
        }[];
    };
    countInformation?: {
        color: RGB;
        name: string;
        size: number;
        fontSize: number;
        visible: boolean;
        points: {
            x: number;
            y: number;
        }[];
    }[];
    slices?: {
        bounds: {
            left: number;
            top: number;
            right: number;
            bottom: number;
        };
        groupName: string;
        slices: {
            id: number;
            groupId: number;
            origin: 'userGenerated' | 'autoGenerated' | 'layer';
            associatedLayerId: number;
            name?: string;
            type: 'image' | 'noImage';
            bounds: {
                left: number;
                top: number;
                right: number;
                bottom: number;
            };
            url: string;
            target: string;
            message: string;
            altTag: string;
            cellTextIsHTML: boolean;
            cellText: string;
            horizontalAlignment: 'default';
            verticalAlignment: 'default';
            backgroundColorType: 'none' | 'matte' | 'color';
            backgroundColor: RGBA;
            topOutset?: number;
            leftOutset?: number;
            bottomOutset?: number;
            rightOutset?: number;
        }[];
    }[];
    layerComps?: {
        list: {
            id: number;
            name: string;
            comment?: string;
            capturedInfo: LayerCompCapturedInfo;
        }[];
        lastApplied?: number;
    };
    copyrighted?: boolean;
    url?: string;
}
export interface GlobalLayerMaskInfo {
    overlayColorSpace: number;
    colorSpace1: number;
    colorSpace2: number;
    colorSpace3: number;
    colorSpace4: number;
    opacity: number;
    kind: number;
}
export interface Annotation {
    type: 'text' | 'sound';
    open: boolean;
    iconLocation: {
        left: number;
        top: number;
        right: number;
        bottom: number;
    };
    popupLocation: {
        left: number;
        top: number;
        right: number;
        bottom: number;
    };
    color: Color;
    author: string;
    name: string;
    date: string;
    data: string | Uint8Array;
}
export declare const enum ChannelID {
    Color0 = 0,
    Color1 = 1,
    Color2 = 2,
    Color3 = 3,
    Transparency = -1,
    UserMask = -2,
    RealUserMask = -3
}
export declare const enum Compression {
    RawData = 0,
    RleCompressed = 1,
    ZipWithoutPrediction = 2,
    ZipWithPrediction = 3
}
export interface LayerRawDataChannel {
    id: ChannelID;
    compression: Compression;
    data: Uint8Array | undefined;
}
export interface LayerRawData {
    colorMode: ColorMode;
    bitsPerChannel: number;
    channels: LayerRawDataChannel[];
    large: boolean;
}
export interface Layer extends LayerAdditionalInfo {
    top?: number;
    left?: number;
    bottom?: number;
    right?: number;
    blendMode?: BlendMode;
    opacity?: number;
    transparencyProtected?: boolean;
    effectsOpen?: boolean;
    hidden?: boolean;
    clipping?: boolean;
    canvas?: HTMLCanvasElement;
    imageData?: PixelData;
    rawData?: LayerRawData;
    children?: Layer[];
    /** Applies only for layer groups. */
    opened?: boolean;
    linkGroup?: number;
    linkGroupEnabled?: boolean;
}
export interface Psd extends LayerAdditionalInfo {
    width: number;
    height: number;
    channels?: number;
    bitsPerChannel?: number;
    colorMode?: ColorMode;
    palette?: RGB[];
    children?: Layer[];
    canvas?: HTMLCanvasElement;
    imageData?: PixelData;
    imageResources?: ImageResources;
    linkedFiles?: LinkedFile[];
    artboards?: {
        count: number;
        autoExpandOffset?: {
            horizontal: number;
            vertical: number;
        };
        origin?: {
            horizontal: number;
            vertical: number;
        };
        autoExpandEnabled?: boolean;
        autoNestEnabled?: boolean;
        autoPositionEnabled?: boolean;
        shrinkwrapOnSaveEnabled?: boolean;
        docDefaultNewArtboardBackgroundColor?: Color;
        docDefaultNewArtboardBackgroundType?: number;
    };
    globalLayerMaskInfo?: GlobalLayerMaskInfo;
    annotations?: Annotation[];
}
export interface ReadOptions {
    /** Does not load layer image data. */
    skipLayerImageData?: boolean;
    /** Does not load composite image data. */
    skipCompositeImageData?: boolean;
    /** Does not load thumbnail. */
    skipThumbnail?: boolean;
    /** Does not load linked files (used in smart-objects). */
    skipLinkedFilesData?: boolean;
    /** Throws exception if features are missing. */
    throwForMissingFeatures?: boolean;
    /** Logs if features are missing. */
    logMissingFeatures?: boolean;
    /** Keep image data as byte array instead of canvas.
     * (image data will appear in `imageData` fields instead of `canvas` fields)
     * This avoids issues with canvas premultiplied alpha corrupting image data. */
    useImageData?: boolean;
    useRawData?: boolean;
    /** Loads thumbnail raw data instead of decoding it's content into canvas.
     * `thumnailRaw` field is used instead. */
    useRawThumbnail?: boolean;
    /** Used only for development. */
    logDevFeatures?: boolean;
    /** Used only for development. */
    strict?: boolean;
    /** Used only for development. */
    debug?: boolean;
    /** Used only for development. */
    log?: (...args: any[]) => void;
}
export interface WriteOptions {
    /** Automatically generates thumbnail from composite image. */
    generateThumbnail?: boolean;
    /** Trims transparent pixels from layer image data. */
    trimImageData?: boolean;
    /** Invalidates text layer data, forcing Photoshop to redraw them on load.
     *  Use this option if you're updating loaded text layer properties. */
    invalidateTextLayers?: boolean;
    /** Logs if features are missing. */
    logMissingFeatures?: boolean;
    /** Forces bottom layer to be treated as layer and not background even when it's missing any transparency
     * 	(by default Photoshop treats bottom layer as background it it doesn't have any transparent pixels). */
    noBackground?: boolean;
    /** Saves document as PSB (Large Document Format) file. */
    psb?: boolean;
    /** Uses zip compression when writing PSD file, will result in smaller file size but may be incompatible
     *  with some software. It may also be significantly slower. */
    compress?: boolean;
}
export {};
