import type { KVNamespace } from "@cloudflare/workers-types";
import type { Jsonifiable } from "type-fest";
/**
 * Add a global, low-latency key-value data storage to your Edge-first
 * application.
 */
export declare class KV {
    protected kv: KVNamespace;
    constructor(kv: KVNamespace);
    get binding(): KVNamespace<string>;
    /**
     * Retrieves all keys from the KV storage.
     * @param prefix The prefix to filter keys by.
     * @param options The options to use when fetching keys.
     */
    keys<Meta = unknown>(prefix: KV.Keys.Prefix, options?: KV.Keys.Options): Promise<KV.Keys.Result<Meta>>;
    keys<Meta = unknown>(options?: KV.Keys.Options): Promise<KV.Keys.Result<Meta>>;
    keys<Meta = unknown>(): Promise<KV.Keys.Result<Meta>>;
    /**
     * Retrieves an item from the Key-Value storage.
     * @param key The key to retrieve.
     * @returns The value and metadata of the key.
     */
    get<Value extends KV.Get.Value, Meta = KV.Get.Meta>(key: KV.Get.Key): Promise<KV.Get.Output<Value, Meta>>;
    /**
     * Puts an item in the storage.
     * @param key The key to set.
     * @param value The value to store, it must be serializable to JSON.
     * @param options The options to use when setting the key.
     */
    set<Value extends KV.Set.Value, Meta extends KV.Set.Meta>(key: KV.Set.Key, value: Value, options?: KV.Set.Options<Meta>): Promise<void>;
    /**
     * Checks if an item exists in the storage.
     * @param key The key to check.
     * @returns Whether the key exists or not.
     */
    has(key: KV.Has.Key): Promise<KV.Has.Output>;
    /**
     * Delete an item from the storage.
     * @param key The key to delete.
     */
    remove(key: KV.Remove.Key): Promise<void>;
}
export declare namespace KV {
    interface Key<Meta = unknown> {
        /** The name of the key. */
        name: string;
        /** The metadata stored along the key. */
        meta: Meta | undefined;
        /** The time-to-live of the key. */
        ttl?: number;
    }
    namespace Keys {
        type Prefix = string;
        interface Options {
            /** The maximum number of keys to return. */
            limit?: number;
            /** The cursor to use when fetching more pages of keys. */
            cursor?: string;
        }
        type Result<Meta = unknown> = {
            keys: Key<Meta>[];
            cursor: null;
            done: true;
        } | {
            keys: Key<Meta>[];
            cursor: string;
            done: false;
        };
    }
    namespace Get {
        type Key = string;
        type Value = Jsonifiable;
        type Meta = Record<string, string>;
        interface Output<T, M = unknown> {
            /**
             * The value stored along the key.
             * It will be null if the key was not found.
             */
            data: T | null;
            /**
             * The metadata stored along the key.
             */
            meta: M | null;
        }
    }
    namespace Set {
        type Key = string;
        type Value = Jsonifiable;
        type Meta = Record<string, string>;
        interface Options<T extends Meta> {
            /**
             * The time-to-live of the key.
             */
            ttl?: number;
            /**
             * Extra metadata to store along the key.
             */
            metadata?: T;
        }
    }
    namespace Has {
        type Key = string;
        type Output = boolean;
    }
    namespace Remove {
        type Key = string;
    }
}