@frostpillar/frostpillar-storage-engine 0.0.1

package/dist/storage/backend/types.d.ts

@@ -0,0 +1,184 @@
+import type { BTreeJSON, CapacityPolicy } from '../../types.js';
+export interface CapacityState {
+    maxSizeBytes: number;
+    policy: CapacityPolicy;
+}
+export interface FileAutoCommitState {
+    frequency: 'immediate' | 'scheduled';
+    intervalMs: number | null;
+    maxPendingBytes: number | null;
+}
+export type IntervalTimerHandle = ReturnType<typeof setInterval>;
+export interface FileGenerationSnapshot {
+    magic: string;
+    version: number;
+    treeJSON: BTreeJSON<unknown, unknown>;
+}
+export interface FileSidecarSnapshot {
+    magic: string;
+    version: number;
+    activeDataFile: string;
+    commitId: number;
+}
+export interface FileBackendState {
+    dataFilePath: string;
+    directoryPath: string;
+    baseFileName: string;
+    sidecarPath: string;
+    lockPath: string;
+    activeDataFile: string;
+    commitId: number;
+    lockAcquired: boolean;
+}
+export interface DurableBackendController {
+    handleRecordAppended(encodedBytes: number): Promise<void>;
+    handleCleared(): Promise<void>;
+    commitNow(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface LocalStorageAdapter {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export interface LocalStorageBackendState {
+    adapter: LocalStorageAdapter;
+    keyPrefix: string;
+    databaseKey: string;
+    maxChunkChars: number;
+    maxChunks: number;
+    activeGeneration: number;
+    commitId: number;
+    activeChunkCount: number;
+}
+export interface LocalStorageManifest {
+    magic: string;
+    version: number;
+    activeGeneration: number;
+    commitId: number;
+    chunkCount: number;
+}
+export interface SyncStorageAdapter {
+    getItems(keys: string[]): Promise<Record<string, unknown>>;
+    setItems(items: Record<string, unknown>): Promise<void>;
+    removeItems(keys: string[]): Promise<void>;
+}
+export interface BrowserSyncStorageAreaPromiseAdapter {
+    get(keys: string | string[] | null): Promise<Record<string, unknown>>;
+    set(items: Record<string, unknown>): Promise<void>;
+    remove(keys: string | string[]): Promise<void>;
+}
+export interface ChromeRuntimeLastError {
+    message?: string;
+}
+export interface ChromeRuntimeAdapter {
+    lastError?: ChromeRuntimeLastError;
+}
+export interface ChromeSyncStorageAreaCallbackAdapter {
+    get(keys: string | string[] | null, callback: (items: Record<string, unknown>) => void): void;
+    set(items: Record<string, unknown>, callback: () => void): void;
+    remove(keys: string | string[], callback: () => void): void;
+}
+export interface SyncStorageBackendState {
+    adapter: SyncStorageAdapter;
+    keyPrefix: string;
+    databaseKey: string;
+    maxChunkChars: number;
+    maxChunks: number;
+    maxItemBytes: number;
+    maxTotalBytes: number;
+    maxItems: number;
+    activeGeneration: number;
+    commitId: number;
+    activeChunkCount: number;
+}
+export interface SyncStorageManifest {
+    magic: string;
+    version: number;
+    activeGeneration: number;
+    commitId: number;
+    chunkCount: number;
+}
+export interface IDBRequestHandle<T> {
+    result: T;
+    onsuccess: ((event: {
+        target: IDBRequestHandle<T>;
+    }) => void) | null;
+    onerror: ((event: {
+        target: IDBRequestHandle<T>;
+    }) => void) | null;
+}
+export interface IDBTreeRecord {
+    magic: string;
+    version: number;
+    commitId: number;
+    treeJSON: BTreeJSON<unknown, unknown>;
+}
+export interface IDBObjectStoreHandle {
+    get(key: string): IDBRequestHandle<IDBTreeRecord | undefined>;
+    put(value: IDBTreeRecord, key?: string): IDBRequestHandle<string>;
+    clear(): IDBRequestHandle<undefined>;
+}
+export interface IDBTransactionHandle {
+    oncomplete: (() => void) | null;
+    onerror: (() => void) | null;
+    objectStore(name: string): IDBObjectStoreHandle;
+}
+export interface IDBDatabaseHandle {
+    close(): void;
+    createObjectStore(name: string, options?: {
+        keyPath?: string;
+    }): IDBObjectStoreHandle;
+    objectStoreNames: {
+        contains(name: string): boolean;
+    };
+    transaction(storeNames: string[], mode: string): IDBTransactionHandle;
+}
+export interface IDBOpenRequestHandle {
+    result: IDBDatabaseHandle | null;
+    error: Error | null;
+    onsuccess: ((event: {
+        target: IDBOpenRequestHandle;
+    }) => void) | null;
+    onerror: ((event: {
+        target: IDBOpenRequestHandle;
+    }) => void) | null;
+    onupgradeneeded: ((event: {
+        target: IDBOpenRequestHandle;
+        oldVersion: number;
+        newVersion: number;
+    }) => void) | null;
+}
+export interface IDBFactoryAdapter {
+    open(name: string, version?: number): IDBOpenRequestHandle;
+}
+export interface OpfsFileWritable {
+    write(data: string): Promise<void>;
+    close(): Promise<void>;
+}
+export interface OpfsFileHandle {
+    getFile(): Promise<{
+        text(): Promise<string>;
+    }>;
+    createWritable(opts?: {
+        keepExistingData?: boolean;
+    }): Promise<OpfsFileWritable>;
+}
+export interface OpfsDirectoryHandle {
+    getDirectoryHandle(name: string, opts?: {
+        create?: boolean;
+    }): Promise<OpfsDirectoryHandle>;
+    getFileHandle(name: string, opts?: {
+        create?: boolean;
+    }): Promise<OpfsFileHandle>;
+    removeEntry(name: string): Promise<void>;
+}
+export interface OpfsStorageRoot {
+    getDirectory(): Promise<OpfsDirectoryHandle>;
+}
+export interface OpfsManifest {
+    magic: string;
+    version: number;
+    activeData: 'a' | 'b';
+    commitId: number;
+}

package/dist/storage/backend/types.js

@@ -0,0 +1 @@
+export {};

package/dist/storage/btree/recordKeyIndexBTree.d.ts

@@ -0,0 +1,39 @@
+import { type BTreeEntry, type BTreeJSON, type DuplicateKeyPolicy, type EntryId } from '@frostpillar/frostpillar-btree';
+export type { BTreeEntry, BTreeJSON, DuplicateKeyPolicy, EntryId };
+export interface RecordKeyIndexBTreeStats {
+    height: number;
+    leafCount: number;
+    branchCount: number;
+    entryCount: number;
+}
+export interface RecordKeyIndexBTreeConfig<TKey> {
+    compareKeys: (left: TKey, right: TKey) => number;
+    duplicateKeys?: DuplicateKeyPolicy;
+}
+export declare const normalizeComparatorResult: (compared: number) => number;
+export declare const clampComparatorResult: (compared: number) => number;
+export declare class RecordKeyIndexBTree<TKey = unknown, TValue = unknown> {
+    private readonly tree;
+    constructor(config: RecordKeyIndexBTreeConfig<TKey>);
+    put(key: TKey, value: TValue): EntryId;
+    putMany(entries: readonly {
+        key: TKey;
+        value: TValue;
+    }[]): EntryId[];
+    peekById(entryId: EntryId): BTreeEntry<TKey, TValue> | null;
+    updateById(entryId: EntryId, value: TValue): BTreeEntry<TKey, TValue> | null;
+    removeById(entryId: EntryId): BTreeEntry<TKey, TValue> | null;
+    rangeQuery(start: TKey, end: TKey): BTreeEntry<TKey, TValue>[];
+    deleteRange(start: TKey, end: TKey): number;
+    snapshot(): BTreeEntry<TKey, TValue>[];
+    peekLast(): BTreeEntry<TKey, TValue> | null;
+    popFirst(): BTreeEntry<TKey, TValue> | null;
+    size(): number;
+    findFirst(key: TKey): BTreeEntry<TKey, TValue> | null;
+    findLast(key: TKey): BTreeEntry<TKey, TValue> | null;
+    hasKey(key: TKey): boolean;
+    keys(): IterableIterator<TKey>;
+    toJSON(): BTreeJSON<TKey, TValue>;
+    static fromJSON<TKey, TValue>(json: BTreeJSON<TKey, TValue>, config: RecordKeyIndexBTreeConfig<TKey>): RecordKeyIndexBTree<TKey, TValue>;
+    clear(): void;
+}

package/dist/storage/btree/recordKeyIndexBTree.js

@@ -0,0 +1,104 @@
+import { InMemoryBTree, } from '@frostpillar/frostpillar-btree';
+import { IndexCorruptionError } from '../../errors/index.js';
+export const normalizeComparatorResult = (compared) => {
+    if (!Number.isFinite(compared) || !Number.isInteger(compared)) {
+        throw new IndexCorruptionError('key comparator must return a finite integer result.');
+    }
+    if (compared === 0) {
+        return 0;
+    }
+    return compared < 0 ? -1 : 1;
+};
+// Lightweight clamper for hot-path comparator wrapping — no validation overhead.
+export const clampComparatorResult = (compared) => {
+    if (compared === 0)
+        return 0;
+    return compared < 0 ? -1 : 1;
+};
+const buildWrappedComparator = (compareKeys) => {
+    return (left, right) => {
+        const result = compareKeys(left, right);
+        // NaN check: x !== x is true only for NaN. Prevents silent BTree corruption.
+        if (result !== result) {
+            throw new IndexCorruptionError('key comparator must not return NaN.');
+        }
+        return clampComparatorResult(result);
+    };
+};
+export class RecordKeyIndexBTree {
+    tree;
+    constructor(config) {
+        const wrappedComparator = buildWrappedComparator(config.compareKeys);
+        const treeConfig = {
+            compareKeys: wrappedComparator,
+            duplicateKeys: config.duplicateKeys ?? 'allow',
+            enableEntryIdLookup: true,
+        };
+        this.tree = new InMemoryBTree(treeConfig);
+    }
+    put(key, value) {
+        return this.tree.put(key, value);
+    }
+    putMany(entries) {
+        return this.tree.putMany(entries);
+    }
+    peekById(entryId) {
+        return this.tree.peekById(entryId);
+    }
+    updateById(entryId, value) {
+        return this.tree.updateById(entryId, value);
+    }
+    removeById(entryId) {
+        return this.tree.removeById(entryId);
+    }
+    rangeQuery(start, end) {
+        return this.tree.range(start, end);
+    }
+    deleteRange(start, end) {
+        return this.tree.deleteRange(start, end, {
+            lowerBound: 'inclusive',
+            upperBound: 'inclusive',
+        });
+    }
+    snapshot() {
+        return this.tree.snapshot();
+    }
+    peekLast() {
+        return this.tree.peekLast();
+    }
+    popFirst() {
+        return this.tree.popFirst();
+    }
+    size() {
+        return this.tree.size();
+    }
+    findFirst(key) {
+        return this.tree.findFirst(key);
+    }
+    findLast(key) {
+        return this.tree.findLast(key);
+    }
+    hasKey(key) {
+        return this.tree.hasKey(key);
+    }
+    keys() {
+        return this.tree.keys();
+    }
+    toJSON() {
+        return this.tree.toJSON();
+    }
+    static fromJSON(json, config) {
+        const wrappedComparator = buildWrappedComparator(config.compareKeys);
+        const adapter = Object.create(RecordKeyIndexBTree.prototype);
+        const resolvedPolicy = config.duplicateKeys ?? 'allow';
+        const patchedJSON = resolvedPolicy !== json.config.duplicateKeys
+            ? { ...json, config: { ...json.config, duplicateKeys: resolvedPolicy } }
+            : json;
+        adapter.tree =
+            InMemoryBTree.fromJSON(patchedJSON, wrappedComparator);
+        return adapter;
+    }
+    clear() {
+        this.tree.clear();
+    }
+}

package/dist/storage/config/config.browser.d.ts

@@ -0,0 +1,4 @@
+import type { FileBackendConfig } from '../../types.js';
+export { parseCapacityConfig, parseAutoCommitConfig, } from './config.shared.js';
+export declare const ensureCanonicalPathWithinWorkingDirectory: (_targetPath: string, _optionName: string) => void;
+export declare const resolveFileDataPath: (_config: FileBackendConfig) => string;

package/dist/storage/config/config.browser.js

@@ -0,0 +1,8 @@
+import { UnsupportedBackendError } from '../../errors/index.js';
+export { parseCapacityConfig, parseAutoCommitConfig, } from './config.shared.js';
+export const ensureCanonicalPathWithinWorkingDirectory = (_targetPath, _optionName) => {
+    throw new UnsupportedBackendError('Path canonicalization is unavailable in browser bundle profile "core".');
+};
+export const resolveFileDataPath = (_config) => {
+    throw new UnsupportedBackendError('File backend path resolution is unavailable in browser bundle profile "core".');
+};

package/dist/storage/config/config.d.ts

@@ -0,0 +1 @@
+export * from './config.shared.js';

package/dist/storage/config/config.js

@@ -0,0 +1 @@
+export * from './config.shared.js';

package/dist/storage/config/config.node.d.ts

@@ -0,0 +1,4 @@
+import type { FileBackendConfig } from '../../types.js';
+export { parseCapacityConfig, parseAutoCommitConfig, } from './config.shared.js';
+export declare const ensureCanonicalPathWithinWorkingDirectory: (targetPath: string, optionName: string) => void;
+export declare const resolveFileDataPath: (config: FileBackendConfig) => string;

package/dist/storage/config/config.node.js

@@ -0,0 +1,74 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { ConfigurationError } from '../../errors/index.js';
+export { parseCapacityConfig, parseAutoCommitConfig, } from './config.shared.js';
+const containsPathTraversalToken = (value) => {
+    return value.includes('..');
+};
+const hasPathSeparator = (value) => {
+    return value.includes('/') || value.includes('\\');
+};
+const isPathWithinBaseDirectory = (targetPath, baseDirectory) => {
+    const relativePath = relative(baseDirectory, targetPath);
+    return (relativePath === '' ||
+        (!relativePath.startsWith('..') && !isAbsolute(relativePath)));
+};
+const resolveNearestExistingAncestor = (targetPath) => {
+    let currentPath = resolve(targetPath);
+    while (!existsSync(currentPath)) {
+        const parentPath = dirname(currentPath);
+        if (parentPath === currentPath) {
+            break;
+        }
+        currentPath = parentPath;
+    }
+    return currentPath;
+};
+const resolveCanonicalPathForContainment = (targetPath) => {
+    const resolvedTargetPath = resolve(targetPath);
+    const nearestExistingAncestor = resolveNearestExistingAncestor(resolvedTargetPath);
+    const canonicalAncestor = realpathSync(nearestExistingAncestor);
+    const relativeSuffix = relative(nearestExistingAncestor, resolvedTargetPath);
+    return resolve(join(canonicalAncestor, relativeSuffix));
+};
+export const ensureCanonicalPathWithinWorkingDirectory = (targetPath, optionName) => {
+    const canonicalWorkingDirectory = realpathSync(resolve(process.cwd()));
+    const canonicalTargetPath = resolveCanonicalPathForContainment(targetPath);
+    if (!isPathWithinBaseDirectory(canonicalTargetPath, canonicalWorkingDirectory)) {
+        throw new ConfigurationError(`${optionName} must stay within process.cwd().`);
+    }
+};
+const ensureSafeFileNameFragment = (value, optionName) => {
+    if (hasPathSeparator(value) || containsPathTraversalToken(value)) {
+        throw new ConfigurationError(`${optionName} must not contain path separators or traversal tokens.`);
+    }
+};
+export const resolveFileDataPath = (config) => {
+    if (config.filePath !== undefined && config.target !== undefined) {
+        throw new ConfigurationError('filePath and target cannot be specified together.');
+    }
+    if (config.filePath !== undefined) {
+        const resolvedFilePath = resolve(config.filePath);
+        ensureCanonicalPathWithinWorkingDirectory(resolvedFilePath, 'filePath');
+        return resolvedFilePath;
+    }
+    if (config.target === undefined) {
+        return resolve('./frostpillar.fpdb');
+    }
+    if (config.target.kind === 'path') {
+        const resolvedFilePath = resolve(config.target.filePath);
+        ensureCanonicalPathWithinWorkingDirectory(resolvedFilePath, 'target.filePath');
+        return resolvedFilePath;
+    }
+    const directoryPath = resolve(config.target.directory);
+    ensureCanonicalPathWithinWorkingDirectory(directoryPath, 'target.directory');
+    const filePrefix = config.target.filePrefix ?? '';
+    const fileName = config.target.fileName ?? 'frostpillar';
+    ensureSafeFileNameFragment(filePrefix, 'target.filePrefix');
+    ensureSafeFileNameFragment(fileName, 'target.fileName');
+    const resolvedFilePath = resolve(join(directoryPath, `${filePrefix}${fileName}.fpdb`));
+    if (!isPathWithinBaseDirectory(resolvedFilePath, directoryPath)) {
+        throw new ConfigurationError('Resolved file path must stay within target.directory.');
+    }
+    return resolvedFilePath;
+};

package/dist/storage/config/config.shared.d.ts

@@ -0,0 +1,6 @@
+import type { AutoCommitConfig, CapacityConfig, DuplicateKeyPolicy } from '../../types.js';
+import type { CapacityState, FileAutoCommitState } from '../backend/types.js';
+export declare const parseCapacityConfig: (capacity?: CapacityConfig) => CapacityState | null;
+export declare const parseAutoCommitConfig: (autoCommit?: AutoCommitConfig) => FileAutoCommitState;
+/** Validates and defaults `duplicateKeys` config. Safe for JS callers passing arbitrary values. */
+export declare const parseDuplicateKeyConfig: (duplicateKeys?: DuplicateKeyPolicy) => DuplicateKeyPolicy;

package/dist/storage/config/config.shared.js

@@ -0,0 +1,105 @@
+import { ConfigurationError } from '../../errors/index.js';
+const BYTE_SIZE_REGEX = /^(\d+)(B|KB|MB|GB)$/;
+const BYTE_SIZE_MULTIPLIER = {
+    B: 1,
+    KB: 1024,
+    MB: 1024 * 1024,
+    GB: 1024 * 1024 * 1024,
+};
+const FREQUENCY_REGEX = /^(\d+)(ms|s|m|h)$/;
+const FREQUENCY_MULTIPLIER = {
+    ms: 1,
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+};
+const normalizeByteSizeInput = (value) => {
+    if (value === 'backendLimit') {
+        throw new ConfigurationError('capacity.maxSize "backendLimit" must be resolved before capacity parsing.');
+    }
+    if (typeof value === 'number') {
+        if (!Number.isSafeInteger(value) || value <= 0) {
+            throw new ConfigurationError('capacity.maxSize must be a positive safe integer.');
+        }
+        return value;
+    }
+    const matched = BYTE_SIZE_REGEX.exec(value);
+    if (matched === null) {
+        throw new ConfigurationError('capacity.maxSize string must be <positive><B|KB|MB|GB>.');
+    }
+    const amount = Number(matched[1]);
+    if (!Number.isSafeInteger(amount) || amount <= 0) {
+        throw new ConfigurationError('capacity.maxSize must be a positive safe integer.');
+    }
+    const unit = matched[2];
+    const multiplier = BYTE_SIZE_MULTIPLIER[unit];
+    const total = amount * multiplier;
+    if (!Number.isSafeInteger(total) || total <= 0) {
+        throw new ConfigurationError('capacity.maxSize exceeds safe integer range.');
+    }
+    return total;
+};
+export const parseCapacityConfig = (capacity) => {
+    if (capacity === undefined) {
+        return null;
+    }
+    const maxSizeBytes = normalizeByteSizeInput(capacity.maxSize);
+    const policy = capacity.policy ?? 'strict';
+    if (policy !== 'strict' && policy !== 'turnover') {
+        throw new ConfigurationError('capacity.policy must be "strict" or "turnover".');
+    }
+    return { maxSizeBytes, policy };
+};
+const parseFrequencyString = (frequency) => {
+    const matched = FREQUENCY_REGEX.exec(frequency);
+    if (matched === null) {
+        throw new ConfigurationError('autoCommit.frequency string must be one of: <positive>ms, <positive>s, <positive>m, <positive>h.');
+    }
+    const amount = Number(matched[1]);
+    if (!Number.isSafeInteger(amount) || amount <= 0) {
+        throw new ConfigurationError('autoCommit.frequency string amount must be a positive safe integer.');
+    }
+    const unit = matched[2];
+    const multiplier = FREQUENCY_MULTIPLIER[unit];
+    const intervalMs = amount * multiplier;
+    if (!Number.isSafeInteger(intervalMs) || intervalMs <= 0) {
+        throw new ConfigurationError('autoCommit.frequency exceeds safe integer range.');
+    }
+    return intervalMs;
+};
+export const parseAutoCommitConfig = (autoCommit) => {
+    if (autoCommit?.maxPendingBytes !== undefined) {
+        if (!Number.isSafeInteger(autoCommit.maxPendingBytes) ||
+            autoCommit.maxPendingBytes <= 0) {
+            throw new ConfigurationError('autoCommit.maxPendingBytes must be a positive safe integer.');
+        }
+    }
+    const maxPendingBytes = autoCommit?.maxPendingBytes ?? null;
+    const frequency = autoCommit?.frequency;
+    if (frequency === undefined || frequency === 'immediate') {
+        return { frequency: 'immediate', intervalMs: null, maxPendingBytes };
+    }
+    if (typeof frequency === 'number') {
+        if (!Number.isSafeInteger(frequency) || frequency <= 0) {
+            throw new ConfigurationError('autoCommit.frequency number must be a positive safe integer.');
+        }
+        return { frequency: 'scheduled', intervalMs: frequency, maxPendingBytes };
+    }
+    const intervalMs = parseFrequencyString(frequency);
+    return { frequency: 'scheduled', intervalMs, maxPendingBytes };
+};
+const VALID_DUPLICATE_KEY_POLICIES = [
+    'allow',
+    'replace',
+    'reject',
+];
+/** Validates and defaults `duplicateKeys` config. Safe for JS callers passing arbitrary values. */
+export const parseDuplicateKeyConfig = (duplicateKeys) => {
+    if (duplicateKeys === undefined) {
+        return 'allow';
+    }
+    if (!VALID_DUPLICATE_KEY_POLICIES.includes(duplicateKeys)) {
+        throw new ConfigurationError('duplicateKeys must be "allow", "replace", or "reject".');
+    }
+    return duplicateKeys;
+};

package/dist/storage/datastore/Datastore.d.ts

@@ -0,0 +1,47 @@
+import type { DatastoreConfig, DatastoreErrorListener, EntryId, InputRecord, KeyedRecord } from '../../types.js';
+export declare class Datastore {
+    private readonly errorListeners;
+    private keyIndex;
+    private readonly keyDefinition;
+    private readonly duplicateKeyPolicy;
+    private readonly capacityState;
+    private readonly skipPayloadValidation;
+    private readonly lifecycle;
+    private readonly writeMutex;
+    private currentSizeBytes;
+    private backendController;
+    private pendingInit;
+    private pendingInitError;
+    constructor(config: DatastoreConfig);
+    put(record: InputRecord<unknown>): Promise<void>;
+    get(key: unknown): Promise<KeyedRecord<unknown>[]>;
+    getFirst(key: unknown): Promise<KeyedRecord<unknown> | null>;
+    getLast(key: unknown): Promise<KeyedRecord<unknown> | null>;
+    delete(key: unknown): Promise<number>;
+    has(key: unknown): Promise<boolean>;
+    getAll(): Promise<KeyedRecord<unknown>[]>;
+    getRange(start: unknown, end: unknown): Promise<KeyedRecord<unknown>[]>;
+    getMany(keys: unknown[]): Promise<KeyedRecord<unknown>[]>;
+    putMany(records: InputRecord<unknown>[]): Promise<void>;
+    deleteMany(keys: unknown[]): Promise<number>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+    keys(): Promise<unknown[]>;
+    getById(id: EntryId): Promise<KeyedRecord<unknown> | null>;
+    updateById(id: EntryId, patch: Partial<KeyedRecord<unknown>['payload']>): Promise<boolean>;
+    deleteById(id: EntryId): Promise<boolean>;
+    commit(): Promise<void>;
+    on(event: 'error', listener: DatastoreErrorListener): () => void;
+    off(event: 'error', listener: DatastoreErrorListener): void;
+    close(): Promise<void>;
+    private resolvePayload;
+    private putSingle;
+    private putManyStrict;
+    private buildStrictBatchEntries;
+    private deleteSingle;
+    private runWithOpen;
+    private executeWithLifecycle;
+    private runWithOpenExclusive;
+    private applyBackendInitResult;
+    private backfillMissingSizeBytes;
+}