import type { Payload, ReadArchivistFunctions, WriteArchivistFunctions } from '@xyo-network/sdk';
import { PayloadBuilder } from '@xyo-network/sdk';
import { z } from 'zod';
import type { ObjectStoreGetResult, ObjectStoreListPage, ObjectStoreListPageOptions, ObjectStoreMetadata, ObjectStorePutOptions, ObjectStorePutResult, ObjectStoreReader, ObjectStoreWriter } from './objectStore.ts';
export declare const DatalakeObjectPayloadSchema: "network.xyo.dapp.object.bytes" & {
    readonly __schema: true;
};
export declare const DatalakeObjectReferenceSchema: "network.xyo.dapp.object.reference" & {
    readonly __schema: true;
};
export declare const DefaultDatalakeObjectMaximumBytes: number;
export declare const DatalakeObjectPayloadZod: z.ZodObject<{
    schema: z.ZodLiteral<"network.xyo.dapp.object.bytes" & {
        readonly __schema: true;
    }>;
    schemaVersion: z.ZodLiteral<1>;
    storeId: z.ZodString;
    encoding: z.ZodLiteral<"hex">;
    bodyHex: z.ZodString;
    contentHash: z.ZodString;
    size: z.ZodNumber;
}, z.core.$strict>;
export type DatalakeObjectPayload = z.infer<typeof DatalakeObjectPayloadZod>;
export declare const DatalakeObjectReferenceZod: z.ZodObject<{
    schema: z.ZodLiteral<"network.xyo.dapp.object.reference" & {
        readonly __schema: true;
    }>;
    schemaVersion: z.ZodLiteral<1>;
    storeId: z.ZodString;
    payloadHash: z.ZodString;
    contentHash: z.ZodString;
    size: z.ZodNumber;
    metadata: z.ZodObject<{
        cacheControl: z.ZodOptional<z.ZodString>;
        contentEncoding: z.ZodOptional<z.ZodString>;
        contentType: z.ZodOptional<z.ZodString>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.core.$strict>;
}, z.core.$strict>;
export type DatalakeObjectReference = z.infer<typeof DatalakeObjectReferenceZod>;
export type DatalakeObjectHash = Awaited<ReturnType<typeof PayloadBuilder.hash>>;
export type DatalakeObjectDataReader = Pick<ReadArchivistFunctions<Payload, DatalakeObjectHash>, 'get'>;
export interface DatalakeObjectDataStore extends DatalakeObjectDataReader, Pick<WriteArchivistFunctions<Payload, Payload, Payload, DatalakeObjectHash>, 'insert'> {
}
export interface DatalakeObjectReaderOptions {
    /** Exclusive logical-key namespace. Writers require origin-consistent reads;
     * public readers may use the publication's declared cache policy. */
    readonly controlStore: ObjectStoreReader;
    /** The app's own lake; an anonymous viewer is sufficient for public data. */
    readonly dataLake: DatalakeObjectDataReader;
    readonly maximumListKeys?: number;
    readonly maximumObjectBytes?: number;
    readonly maximumReferenceBytes?: number;
    /** Stable logical identity, independent of provider hostname or physical bucket. */
    readonly storeId: string;
}
export interface DatalakeObjectStoreOptions extends DatalakeObjectReaderOptions {
    /** Must provide real atomic conditions and non-reused version tokens. */
    readonly controlStore: ObjectStoreWriter;
    readonly dataLake: DatalakeObjectDataStore;
}
/** A language-neutral binary envelope. Hex is canonical lowercase and costs two
 * characters per original byte; transport limits must include the envelope. */
export declare function encodeDatalakeObjectPayload(body: string | Uint8Array, storeId: string, maximumObjectBytes?: number): DatalakeObjectPayload;
export declare function decodeDatalakeObjectPayload(value: unknown, storeId: string, maximumObjectBytes?: number): Uint8Array;
/** Keyed reads over immutable datalake bodies and a separately qualified atomic
 * reference store. No provider, wallet, network client or lifecycle is acquired. */
export declare class DatalakeObjectReader implements ObjectStoreReader {
    readonly storeId: string;
    protected readonly controlStore: ObjectStoreReader;
    protected readonly dataLake: DatalakeObjectDataReader;
    protected readonly maximumListKeys: number;
    protected readonly maximumObjectBytes: number;
    protected readonly maximumReferenceBytes: number;
    constructor(options: DatalakeObjectReaderOptions);
    get(key: string): Promise<Uint8Array | undefined>;
    getWithMetadata(key: string): Promise<ObjectStoreGetResult | undefined>;
    list(prefix?: string): Promise<readonly string[]>;
    listPage(options?: ObjectStoreListPageOptions): Promise<ObjectStoreListPage>;
    stat(key: string): Promise<ObjectStoreMetadata | undefined>;
    protected readBody(reference: DatalakeObjectReference): Promise<Uint8Array>;
    private readReference;
}
/** Publishes verified immutable bytes before conditionally advancing their keyed
 * reference. A failed/ambiguous reference write never deletes the retained body. */
export declare class DatalakeObjectStore extends DatalakeObjectReader implements ObjectStoreWriter {
    private readonly controlWriter;
    private readonly dataWriter;
    constructor(options: DatalakeObjectStoreOptions);
    /** Removes only the reference. Content retention/garbage collection is a
     * separate operator policy and cannot erase a generation's retained bodies. */
    delete(key: string): Promise<void>;
    put(key: string, body: string | Uint8Array, options?: ObjectStorePutOptions): Promise<ObjectStorePutResult>;
}
//# sourceMappingURL=datalakeObjectStore.d.ts.map