interface PDFRef {
    ObjectNumber: number;
    GenerationNumber: number;
}
declare type PDFValue = null | number | string | boolean;
declare type PDFObject<A> = {
    [key: string]: A | PDFObject<A>;
} | PDFObject<A>[] | A;
declare type PDFObjectWithRefs = PDFObject<PDFValue | PDFRef>;
declare type XPages = {
    Type: 'Pages';
    Kids: PDFRef[];
};
declare type XPage = {
    Type: 'Page';
    Resources: PDFObjectWithRefs;
    Contents: PDFRef;
    MediaBox: number[];
};
declare type StreamDict = {
    Object: {
        Dict: {
            Filter: string;
            Length: number;
        };
        StreamOffset: number;
        StreamLength: number;
    };
};
declare type XObject = {
    Object: XPage | XPages | PDFObjectWithRefs;
} | StreamDict;
interface XRefTable {
    Table: {
        [key: string]: XObject;
    };
    PageCount: number;
    Root: PDFRef;
    RootDict: {
        Pages: PDFRef;
        OCProperties?: OCProperties$1;
    };
    Title: string;
}
declare type OCProperties$1 = {
    D: {
        ON?: PDFRef[];
        OFF?: PDFRef[];
        Order: PDFRef;
        RBGroups: unknown[];
    };
    OCGs: PDFRef[];
};

declare type Frame = {
    width: number;
    height: number;
};
declare type TextLayerRecord = {
    name?: string;
    content: string;
    index: number;
    frame?: Frame;
};

declare type RawPrivateData = () => AsyncGenerator<Uint8Array>;
declare type PrivateData$1 = {
    TextLayers?: TextLayerRecord[];
    LayerNames: string[];
};

declare function parsePrivateData(data: RawPrivateData): Promise<PrivateData$1>;

declare type Differences = (string | number)[];
declare type BaseEncoding = 'WinAnsiEncoding' | 'Identity-H';
declare type DerivedEncodingRef = {
    BaseEncoding: BaseEncoding;
    Differences: Differences;
};
declare type EncodingRef = BaseEncoding | DerivedEncodingRef;
interface FontRef {
    ObjID: number;
    Encoding: EncodingRef;
    ToUnicode?: {
        ObjID: number;
    };
}

declare type DerivedEncoding = {
    BaseEncoding: BaseEncoding;
    Differences: Map<number, string>;
};
declare type Encoding = 'WinAnsiEncoding' | 'Identity-H' | DerivedEncoding;
declare type Font = {
    Encoding: Encoding;
    ToUnicode?: Map<number, string>;
};

interface AIFile {
    XRefTable: XRefTable;
    Version: string;
}
declare type StreamDictFetcher = (objId: number) => Promise<Uint8Array>;
interface Context {
    aiFile: AIFile;
    streamDict: StreamDictFetcher;
    privateData: RawPrivateData;
    externalResourceURLs?: {
        Bitmaps: {
            [key: string]: unknown;
        };
        Fonts: {
            [key: string]: unknown;
        };
    };
    xobjectMutex: Map<number, Promise<unknown[]>>;
    fontCache: Map<number, Promise<Font>>;
    parsedPrivateData?: Promise<PrivateData$1>;
    strictPopplerCompat?: true;
}
declare type ContentsDict = {
    Data: unknown[];
    Kind?: number;
    Length?: unknown;
    Filter?: unknown;
};

declare type ICCBased = {
    Alternate?: string;
    N: number;
};
declare type ColorSpace = ['ICCBased', ICCBased] | ['Separation', unknown, string] | ['Pattern'] | string;

declare type Resources = {
    readonly ColorSpace: Record<string, ColorSpace>;
    readonly ExtGState: Record<string, unknown>;
    readonly Font: Record<string, FontRef>;
};

interface OCRef {
    ObjID: number;
}
declare type OCProperties = {
    D: {
        OFF: OCRef[];
        ON: OCRef[];
    };
};

declare type ArtBoardRef = {
    idx: number;
    ref: PDFRef;
} & {
    readonly '': unique symbol;
};
declare function ArtBoardRefs(ctx: Context): ArtBoardRef[];
declare function PrivateData(ctx: Context): ReturnType<typeof parsePrivateData>;
interface ArtBoard {
    Contents: ContentsDict;
    MediaBox: number[];
    Resources: Resources;
    OCProperties?: OCProperties;
    Name: string;
}
declare function ArtBoard(ctx: Context, ref: ArtBoardRef): Promise<ArtBoard>;

export { ArtBoard, ArtBoardRef, ArtBoardRefs, PrivateData };
//# sourceMappingURL=index.d.ts.map