dataply 0.0.1

package/dist/types/core/Page.d.ts

@@ -0,0 +1,690 @@
+import { DataPage, IndexPage, BitmapPage, OverflowPage, MetadataPage, EmptyPage, UnknownPage } from '../types';
+import { Row } from './Row';
+/**
+ * Manages common methods for each type of page.
+ */
+export declare abstract class PageManager {
+    static readonly CONSTANT: {
+        readonly PAGE_TYPE_UNKNOWN: 0;
+        readonly PAGE_TYPE_EMPTY: 1;
+        readonly PAGE_TYPE_METADATA: 2;
+        readonly PAGE_TYPE_BITMAP: 3;
+        readonly PAGE_TYPE_INDEX: 4;
+        readonly PAGE_TYPE_DATA: 5;
+        readonly PAGE_TYPE_OVERFLOW: 6;
+        readonly SIZE_PAGE_HEADER: 100;
+        readonly SIZE_PAGE_TYPE: 1;
+        readonly SIZE_PAGE_ID: 4;
+        readonly SIZE_NEXT_PAGE_ID: 4;
+        readonly SIZE_INSERTED_ROW_COUNT: 4;
+        readonly SIZE_REMAINING_CAPACITY: 4;
+        readonly SIZE_SLOT_OFFSET: 2;
+        readonly SIZE_CHECKSUM: 4;
+        readonly OFFSET_PAGE_TYPE: 0;
+        readonly OFFSET_PAGE_ID: 1;
+        readonly OFFSET_NEXT_PAGE_ID: 5;
+        readonly OFFSET_INSERTED_ROW_COUNT: 9;
+        readonly OFFSET_REMAINING_CAPACITY: 13;
+        readonly OFFSET_CHECKSUM: 17;
+    };
+    /**
+     * Returns the page type.
+     * @param page Page data
+     * @returns Page type
+     */
+    static GetPageType(page: Uint8Array): number;
+    /**
+     * Returns the page type.
+     * @param page Page data
+     * @returns Page type
+     */
+    getPageType(page: Uint8Array): number;
+    /**
+     * Returns the page ID.
+     * @param page Page data
+     * @returns Page ID
+     */
+    getPageId(page: Uint8Array): number;
+    /**
+     * Returns the ID of the next connected page.
+     * @param page Page data
+     * @returns Next connected page ID
+     */
+    getNextPageId(page: Uint8Array): number;
+    /**
+     * Returns the remaining capacity of the page.
+     * @param page Page data
+     * @returns Remaining capacity
+     */
+    getRemainingCapacity(page: Uint8Array): number;
+    /**
+     * Returns the checksum of the page.
+     * @param page Page data
+     * @returns Checksum
+     */
+    getChecksum(page: Uint8Array): number;
+    /**
+     * Sets the page type.
+     * @param page Page data
+     * @param pageType Page type
+     */
+    setPageType(page: Uint8Array, pageType: number): void;
+    /**
+     * Sets the page ID.
+     * @param page Page data
+     * @param pageId Page ID
+     */
+    setPageId(page: Uint8Array, pageId: number): void;
+    /**
+     * Sets the ID of the next connected page.
+     * @param page Page data
+     * @param nextPageId Next connected page ID
+     */
+    setNextPageId(page: Uint8Array, nextPageId: number): void;
+    /**
+     * Sets the remaining capacity of the page.
+     * @param page Page data
+     * @param remainingCapacity Remaining capacity
+     */
+    setRemainingCapacity(page: Uint8Array, remainingCapacity: number): void;
+    /**
+     * Sets the checksum of the page.
+     * @param page Page data
+     * @param checksum Checksum
+     */
+    setChecksum(page: Uint8Array, checksum: number): void;
+    /**
+     * Updates the checksum of the page.
+     * Calculates the checksum of the page body (excluding the header) and sets it in the header.
+     * @param page Page data
+     */
+    updateChecksum(page: Uint8Array): void;
+    /**
+     * Verifies the checksum of the page.
+     * Calculates the checksum of the page body and compares it with the checksum stored in the header.
+     * @param page Page data
+     * @returns boolean indicating if the checksum is valid
+     */
+    verifyChecksum(page: Uint8Array): boolean;
+    /**
+     * Sets the page header.
+     * @param page Page data
+     * @param header Page header
+     */
+    setHeader(page: Uint8Array, header: Uint8Array): void;
+    /**
+     * Sets the page body.
+     * @param page Page data
+     * @param body Page body
+     */
+    setBody(page: Uint8Array, body: Uint8Array): void;
+    /**
+     * Initializes the page.
+     * @param page Page data
+     * @param pageType Page type
+     * @param pageId Page ID
+     * @param nextPageId Next connected page ID
+     * @param remainingCapacity Remaining capacity
+     */
+    initial(page: Uint8Array, pageType: number, pageId: number, nextPageId: number, remainingCapacity: number): void;
+    /**
+     * Returns the body of the page.
+     * @param page Page data
+     * @returns Page body
+     */
+    getBody(page: Uint8Array): Uint8Array;
+    /**
+     * Returns the page type.
+     */
+    abstract get pageType(): number;
+    /**
+     * Creates a new page.
+     * @param pageSize Page size
+     * @param pageId Page ID
+     * @returns Created page data
+     */
+    create(pageSize: number, pageId: number): Uint8Array;
+}
+/**
+ * Represents that a page is empty.
+ */
+export declare class EmptyPageManager extends PageManager {
+    get pageType(): 1;
+    /**
+     * Checks if the page type is `EmptyPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `EmptyPage`
+     */
+    static IsEmptyPage(page: Uint8Array): page is EmptyPage;
+    /**
+     * Checks if the page type is `EmptyPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `EmptyPage`
+     */
+    isEmptyPage(page: Uint8Array): page is EmptyPage;
+}
+/**
+ * Represents a data page.
+ * A data page is where actual data is stored.
+ * Rows are stored in data pages. The position where a row is stored is determined by the slot offset.
+ * Slot offsets occupy 2 bytes each starting from the end of the page.
+ *
+ * If the row size is larger than the remaining capacity of the page, a new page is created and used.
+ * If the row size is larger than the page size itself, it is stored in an overflow page.
+ * In this case, the row has its overflow flag set in the header, and the body stores the ID of the overflow page.
+ */
+export declare class DataPageManager extends PageManager {
+    get pageType(): 5;
+    protected readonly row: Row;
+    /**
+     * Checks if the page type is `DataPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `DataPage`
+     */
+    static IsDataPage(page: Uint8Array): page is DataPage;
+    /**
+     * Checks if the page type is `DataPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `DataPage`
+     */
+    isDataPage(page: Uint8Array): page is DataPage;
+    /**
+     * Returns the offset of a row within the page.
+     * @param page Page data
+     * @param slotIndex Slot index
+     * @returns Row offset within the page
+     */
+    getRowOffset(page: DataPage, slotIndex: number): number;
+    /**
+     * Returns the row from the page.
+     * @param page Page data
+     * @param slotIndex Slot index
+     * @returns Row data within the page
+     */
+    getRow(page: DataPage, slotIndex: number): Uint8Array;
+    /**
+     * Returns the number of rows inserted into the page.
+     * @param page Page data
+     * @returns Number of rows inserted
+     */
+    getInsertedRowCount(page: Uint8Array): number;
+    /**
+     * Sets the offset of a row within the page.
+     * @param page Page data
+     * @param slotIndex Slot index
+     * @param offset Row offset within the page
+     */
+    setRowOffset(page: DataPage, slotIndex: number, offset: number): void;
+    /**
+     * Sets the number of rows inserted into the page.
+     * @param page Page data
+     * @param insertedRowCount Number of rows inserted
+     */
+    setInsertedRowCount(page: Uint8Array, insertedRowCount: number): void;
+    /**
+     * Calculates if there is space for a row in the page and determines insertability.
+     * If insertable, returns the slot index to be inserted.
+     * If not, returns -1.
+     * @param page Page data
+     * @param row Row data
+     * @returns Slot index for the row
+     */
+    getNextSlotIndex(page: DataPage, row: Uint8Array): number;
+    /**
+     * Returns the position for the next row to be inserted.
+     * @param page Page data
+     * @returns Next insert position
+     */
+    getNextInsertPosition(page: DataPage): number;
+    /**
+     * Inserts a row into the page. `getNextSlotIndex` should be called beforehand to verify availability.
+     * @param page Page data
+     * @param row Row data
+     */
+    insert(page: DataPage, row: Uint8Array): void;
+}
+/**
+ * Represents an index page.
+ * An index page is used to store page indices.
+ */
+export declare class IndexPageManager extends PageManager {
+    get pageType(): 4;
+    static readonly CONSTANT: {
+        readonly OFFSET_INDEX_ID: 100;
+        readonly OFFSET_PARENT_INDEX_ID: 104;
+        readonly OFFSET_NEXT_INDEX_ID: 108;
+        readonly OFFSET_PREV_INDEX_ID: 112;
+        readonly OFFSET_IS_LEAF: 116;
+        readonly OFFSET_KEYS_COUNT: 117;
+        readonly OFFSET_VALUES_COUNT: 121;
+        readonly OFFSET_KEYS_AND_VALUES: 128;
+        readonly SIZE_INDEX_ID: 4;
+        readonly SIZE_PARENT_INDEX_ID: 4;
+        readonly SIZE_NEXT_INDEX_ID: 4;
+        readonly SIZE_PREV_INDEX_ID: 4;
+        readonly SIZE_IS_LEAF: 1;
+        readonly SIZE_KEYS_COUNT: 4;
+        readonly SIZE_VALUES_COUNT: 4;
+        readonly SIZE_KEY: 8;
+        readonly SIZE_VALUE: 8;
+        readonly PAGE_TYPE_UNKNOWN: 0;
+        readonly PAGE_TYPE_EMPTY: 1;
+        readonly PAGE_TYPE_METADATA: 2;
+        readonly PAGE_TYPE_BITMAP: 3;
+        readonly PAGE_TYPE_INDEX: 4;
+        readonly PAGE_TYPE_DATA: 5;
+        readonly PAGE_TYPE_OVERFLOW: 6;
+        readonly SIZE_PAGE_HEADER: 100;
+        readonly SIZE_PAGE_TYPE: 1;
+        readonly SIZE_PAGE_ID: 4;
+        readonly SIZE_NEXT_PAGE_ID: 4;
+        readonly SIZE_INSERTED_ROW_COUNT: 4;
+        readonly SIZE_REMAINING_CAPACITY: 4;
+        readonly SIZE_SLOT_OFFSET: 2;
+        readonly SIZE_CHECKSUM: 4;
+        readonly OFFSET_PAGE_TYPE: 0;
+        readonly OFFSET_PAGE_ID: 1;
+        readonly OFFSET_NEXT_PAGE_ID: 5;
+        readonly OFFSET_INSERTED_ROW_COUNT: 9;
+        readonly OFFSET_REMAINING_CAPACITY: 13;
+        readonly OFFSET_CHECKSUM: 17;
+    };
+    /**
+     * Checks if the page type is `IndexPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `IndexPage`
+     */
+    static IsIndexPage(page: Uint8Array): page is IndexPage;
+    /**
+     * Checks if the page type is `IndexPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `IndexPage`
+     */
+    isIndexPage(page: Uint8Array): page is IndexPage;
+    /**
+     * Gets the index ID of the page.
+     * @param page Page data
+     * @returns Index ID
+     */
+    getIndexId(page: Uint8Array): number;
+    /**
+     * Gets the parent index ID of the page.
+     * @param page Page data
+     * @returns Parent index ID
+     */
+    getParentIndexId(page: Uint8Array): number;
+    /**
+     * Gets the next index ID of the page.
+     * @param page Page data
+     * @returns Next index ID
+     */
+    getNextIndexId(page: Uint8Array): number;
+    /**
+     * Gets the previous index ID of the page.
+     * @param page Page data
+     * @returns Previous index ID
+     */
+    getPrevIndexId(page: Uint8Array): number;
+    /**
+     * Gets the is leaf of the page.
+     * @param page Page data
+     * @returns Is leaf
+     */
+    getIsLeaf(page: Uint8Array): boolean;
+    /**
+     * Gets the keys count of the page.
+     * @param page Page data
+     * @returns Keys count
+     */
+    getKeysCount(page: Uint8Array): number;
+    /**
+     * Gets the values count of the page.
+     * @param page Page data
+     * @returns Values count
+     */
+    getValuesCount(page: Uint8Array): number;
+    /**
+     * Sets the index ID of the page.
+     * @param page Page data
+     * @param indexId Index ID
+     */
+    setIndexId(page: Uint8Array, indexId: number): void;
+    /**
+     * Sets the parent index ID of the page.
+     * @param page Page data
+     * @param parentIndexId Parent index ID
+     */
+    setParentIndexId(page: Uint8Array, parentIndexId: number): void;
+    /**
+     * Sets the next index ID of the page.
+     * @param page Page data
+     * @param nextIndexId Next index ID
+     */
+    setNextIndexId(page: Uint8Array, nextIndexId: number): void;
+    /**
+     * Sets the previous index ID of the page.
+     * @param page Page data
+     * @param prevIndexId Previous index ID
+     */
+    setPrevIndexId(page: Uint8Array, prevIndexId: number): void;
+    /**
+     * Sets the is leaf of the page.
+     * @param page Page data
+     * @param isLeaf Is leaf
+     */
+    setIsLeaf(page: Uint8Array, isLeaf: boolean): void;
+    /**
+     * Sets the keys count of the page.
+     * @param page Page data
+     * @param keysCount Keys count
+     */
+    setKeysCount(page: Uint8Array, keysCount: number): void;
+    /**
+     * Sets the values count of the page.
+     * @param page Page data
+     * @param valuesCount Values count
+     */
+    setValuesCount(page: Uint8Array, valuesCount: number): void;
+    /**
+     * Gets the keys of the page.
+     * @param page Page data
+     * @returns Keys
+     */
+    getKeys(page: Uint8Array): number[];
+    /**
+     * Gets the values of the page.
+     * @param page Page data
+     * @returns Values
+     */
+    getValues(page: Uint8Array): number[];
+    /**
+     * Sets the keys and values of the page.
+     * @param page Page data
+     * @param keys Keys
+     * @param values Values
+     */
+    setKeysAndValues(page: Uint8Array, keys: number[], values: number[]): void;
+}
+/**
+ * Represents a metadata page.
+ * A metadata page stores database metadata.
+ */
+export declare class MetadataPageManager extends PageManager {
+    get pageType(): 2;
+    static readonly CONSTANT: {
+        readonly MAGIC_STRING: "DATAPLY";
+        readonly OFFSET_MAGIC_STRING: 100;
+        readonly OFFSET_PAGE_COUNT: 108;
+        readonly OFFSET_PAGE_SIZE: 112;
+        readonly OFFSET_ROW_COUNT: 116;
+        readonly OFFSET_ROOT_INDEX_PAGE_ID: 122;
+        readonly OFFSET_ROOT_INDEX_ORDER: 126;
+        readonly OFFSET_LAST_INSERT_PAGE_ID: 130;
+        readonly OFFSET_LAST_ROW_PK: 134;
+        readonly SIZE_PAGE_COUNT: 4;
+        readonly SIZE_PAGE_SIZE: 4;
+        readonly SIZE_ROOT_INDEX_PAGE_ID: 4;
+        readonly SIZE_ROOT_INDEX_ORDER: 4;
+        readonly SIZE_LAST_INSERT_PAGE_ID: 4;
+        readonly PAGE_TYPE_UNKNOWN: 0;
+        readonly PAGE_TYPE_EMPTY: 1;
+        readonly PAGE_TYPE_METADATA: 2;
+        readonly PAGE_TYPE_BITMAP: 3;
+        readonly PAGE_TYPE_INDEX: 4;
+        readonly PAGE_TYPE_DATA: 5;
+        readonly PAGE_TYPE_OVERFLOW: 6;
+        readonly SIZE_PAGE_HEADER: 100;
+        readonly SIZE_PAGE_TYPE: 1;
+        readonly SIZE_PAGE_ID: 4;
+        readonly SIZE_NEXT_PAGE_ID: 4;
+        readonly SIZE_INSERTED_ROW_COUNT: 4;
+        readonly SIZE_REMAINING_CAPACITY: 4;
+        readonly SIZE_SLOT_OFFSET: 2;
+        readonly SIZE_CHECKSUM: 4;
+        readonly OFFSET_PAGE_TYPE: 0;
+        readonly OFFSET_PAGE_ID: 1;
+        readonly OFFSET_NEXT_PAGE_ID: 5;
+        readonly OFFSET_INSERTED_ROW_COUNT: 9;
+        readonly OFFSET_REMAINING_CAPACITY: 13;
+        readonly OFFSET_CHECKSUM: 17;
+    };
+    /**
+     * Checks if the page type is `MetadataPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `MetadataPage`
+     */
+    static IsMetadataPage(page: Uint8Array): page is MetadataPage;
+    /**
+     * Checks if the page type is `MetadataPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `MetadataPage`
+     */
+    isMetadataPage(page: Uint8Array): page is MetadataPage;
+    /**
+     * Verifies if the page is a valid metadata page.
+     * @param page Page data
+     * @returns Whether it is a metadata page
+     */
+    static Verify(page: MetadataPage): boolean;
+    /**
+     * Returns the number of pages stored in the database.
+     * @param page Page data
+     * @returns Number of pages
+     */
+    getPageCount(page: MetadataPage): number;
+    /**
+     * Returns the database page size.
+     * @param page Page data
+     * @returns Page size
+     */
+    getPageSize(page: MetadataPage): number;
+    /**
+     * Returns the Root Index Page ID of the database.
+     * @param page Page data
+     * @returns Root Index Page ID
+     */
+    getRootIndexPageId(page: MetadataPage): number;
+    /**
+     * Returns the order of the database Root Index Page.
+     * @param page Page data
+     * @returns Root Index Page order
+     */
+    getRootIndexOrder(page: MetadataPage): number;
+    /**
+     * Returns the ID of the last insertion page.
+     * @param page Page data
+     * @returns Last insert page ID
+     */
+    getLastInsertPageId(page: MetadataPage): number;
+    /**
+     * Returns the PK of the last inserted row in the database.
+     * @param page Page data
+     * @returns Last inserted row PK
+     */
+    getLastRowPk(page: MetadataPage): number;
+    /**
+     * Returns the number of rows in the database.
+     * @param page Page data
+     * @returns Number of rows
+     */
+    getRowCount(page: MetadataPage): number;
+    /**
+     * Sets the number of pages stored in the database.
+     * @param page Page data
+     * @param pageCount Number of pages
+     */
+    setPageCount(page: MetadataPage, pageCount: number): void;
+    /**
+     * Sets the database page size.
+     * @param page Page data
+     * @param pageSize Page size
+     */
+    setPageSize(page: MetadataPage, pageSize: number): void;
+    /**
+     * Sets the Root Index Page ID of the database.
+     * @param page Page data
+     * @param rootIndexPageId Root Index Page ID
+     */
+    setRootIndexPageId(page: MetadataPage, rootIndexPageId: number): void;
+    /**
+     * Sets the order of the database Root Index Page.
+     * @param page Page data
+     * @param order Root Index Page order
+     */
+    setRootIndexOrder(page: MetadataPage, order: number): void;
+    /**
+     * Sets the magic string of the page.
+     * @param page Page data
+     */
+    setMagicString(page: MetadataPage): void;
+    /**
+     * Sets the ID of the last insertion page.
+     * @param page Page data
+     * @param lastInsertPageId Last insert page ID
+     */
+    setLastInsertPageId(page: MetadataPage, lastInsertPageId: number): void;
+    /**
+     * Sets the PK of the last inserted row in the database.
+     * @param page Page data
+     * @param lastRowPk Last inserted row PK
+     */
+    setLastRowPk(page: MetadataPage, lastRowPk: number): void;
+    /**
+     * Sets the number of rows in the database.
+     * @param page Page data
+     * @param rowCount Number of rows
+     */
+    setRowCount(page: MetadataPage, rowCount: number): void;
+}
+/**
+ * Represents a bitmap page.
+ * A bitmap page stores a bitmap of pages.
+ */
+export declare class BitmapPageManager extends PageManager {
+    get pageType(): 3;
+    /**
+     * Checks if the page type is `BitmapPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `BitmapPage`
+     */
+    static IsBitmapPage(page: Uint8Array): page is BitmapPage;
+    /**
+     * Checks if the page type is `BitmapPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `BitmapPage`
+     */
+    isBitmapPage(page: Uint8Array): page is BitmapPage;
+    /**
+     * Checks if a page is empty.
+     * @param page Page data
+     * @param index Bitmap index
+     * @returns boolean indicating if the page is empty
+     */
+    isEmptyPage(page: BitmapPage, index: number): boolean;
+}
+/**
+ * Represents an overflow page.
+ * An overflow page stores overflow data of pages.
+ * Overflow pages store data of rows in data pages where the overflow flag is set.
+ */
+export declare class OverflowPageManager extends PageManager {
+    get pageType(): 6;
+    /**
+     * Checks if the page type is `OverflowPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `OverflowPage`
+     */
+    static IsOverflowPage(page: Uint8Array): page is OverflowPage;
+    /**
+     * Checks if the page type is `OverflowPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `OverflowPage`
+     */
+    isOverflowPage(page: Uint8Array): page is OverflowPage;
+}
+export declare class UnknownPageManager extends PageManager {
+    get pageType(): 0;
+    /**
+     * Checks if the page type is `UnknownPage`.
+     * @param page Page data
+     * @returns boolean indicating if the page type is `UnknownPage`
+     */
+    static IsUnknownPage(page: Uint8Array): page is UnknownPage;
+    /**
+     * Checks if the page is `UnknownPage`.
+     * @param page Page data
+     * @returns `true` if the page is `UnknownPage`, otherwise `false`
+     */
+    isUnknownPage(page: Uint8Array): page is UnknownPage;
+}
+export declare class PageManagerFactory {
+    protected static readonly EmptyPage: EmptyPageManager;
+    protected static readonly DataPage: DataPageManager;
+    protected static readonly IndexPage: IndexPageManager;
+    protected static readonly MetadataPage: MetadataPageManager;
+    protected static readonly BitmapPage: BitmapPageManager;
+    protected static readonly OverflowPage: OverflowPageManager;
+    protected static readonly UnknownPage: UnknownPageManager;
+    /**
+     * Returns the page type.
+     * @param page Page data
+     * @returns Page type
+     */
+    protected getPageType(page: Uint8Array): number;
+    /**
+     * Checks if the page is `EmptyPage`.
+     * @param page Page data
+     * @returns `true` if the page is `EmptyPage`, otherwise `false`
+     */
+    isEmptyPage(page: Uint8Array): page is EmptyPage;
+    /**
+     * Checks if the page is `DataPage`.
+     * @param page Page data
+     * @returns `true` if the page is `DataPage`, otherwise `false`
+     */
+    isDataPage(page: Uint8Array): page is DataPage;
+    /**
+     * Checks if the page is `IndexPage`.
+     * @param page Page data
+     * @returns `true` if the page is `IndexPage`, otherwise `false`
+     */
+    isIndexPage(page: Uint8Array): page is IndexPage;
+    /**
+     * Checks if the page is `MetadataPage`.
+     * @param page Page data
+     * @returns `true` if the page is `MetadataPage`, otherwise `false`
+     */
+    isMetadataPage(page: Uint8Array): page is MetadataPage;
+    /**
+     * Checks if the page is `BitmapPage`.
+     * @param page Page data
+     * @returns `true` if the page is `BitmapPage`, otherwise `false`
+     */
+    isBitmapPage(page: Uint8Array): page is BitmapPage;
+    /**
+     * Checks if the page is `OverflowPage`.
+     * @param page Page data
+     * @returns `true` if the page is `OverflowPage`, otherwise `false`
+     */
+    isOverflowPage(page: Uint8Array): page is OverflowPage;
+    /**
+     * Checks if the page is `UnknownPage`.
+     * @param page Page data
+     * @returns `true` if the page is `UnknownPage`, otherwise `false`
+     */
+    isUnknownPage(page: Uint8Array): page is UnknownPage;
+    /**
+     * Returns a page manager based on the page type.
+     * @param page Page data
+     * @returns Page manager
+     */
+    getManager(page: EmptyPage): EmptyPageManager;
+    getManager(page: MetadataPage): MetadataPageManager;
+    getManager(page: IndexPage): IndexPageManager;
+    getManager(page: DataPage): DataPageManager;
+    getManager(page: BitmapPage): BitmapPageManager;
+    getManager(page: OverflowPage): OverflowPageManager;
+    getManager(page: UnknownPage): UnknownPageManager;
+    getManager(page: Uint8Array): PageManager;
+    getManagerFromType(pageType: number): PageManager;
+}