declare type BaseEncoding = 'WinAnsiEncoding' | 'Identity-H';

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 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;
    };
    Title: string;
}
declare type OCProperties = {
    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 = {
    TextLayers?: TextLayerRecord[];
    LayerNames: 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>;
    strictPopplerCompat?: true;
}

interface DumpSerializedOpts {
    file: string;
    workdir?: string;
}
interface FsContext extends Context {
    Bitmaps: {
        [key: string]: string;
    };
    Fonts: {
        [key: string]: string;
    };
    StreamDicts: {
        [key: string]: string;
    };
    BaseDir: string;
    PrivateData: string;
}
declare function FSContext(opts: DumpSerializedOpts): Promise<FsContext>;

export { DumpSerializedOpts, FSContext, FsContext };
//# sourceMappingURL=fs_context.d.ts.map