export interface ZveltioClientConfig {
    baseUrl: string;
    apiKey?: string;
    headers?: Record<string, string>;
}
export interface ListParams {
    page?: number;
    limit?: number;
    sort?: string;
    order?: 'asc' | 'desc';
    search?: string;
    filter?: Record<string, any>;
    cursor?: string;
}
export interface ListResult<T> {
    data: T[];
    total: number;
    page: number;
    limit: number;
    next_cursor?: string;
}
declare class CollectionRef<T extends Record<string, any>> {
    private readonly name;
    private readonly client;
    constructor(name: string, client: ZveltioClient<any>);
    list(params?: ListParams): Promise<ListResult<T>>;
    getMany(params?: ListParams): Promise<ListResult<T>>;
    get(id: string): Promise<T>;
    getOne(id: string): Promise<T>;
    create(data: Omit<T, 'id' | 'created_at' | 'updated_at'>): Promise<T>;
    update(id: string, data: Partial<Omit<T, 'id' | 'created_at' | 'updated_at'>>): Promise<T>;
    delete(id: string): Promise<{
        success: boolean;
    }>;
}
/**
 * ZveltioClient — generic over your schema type.
 *
 * Usage with generated types (run `zveltio generate-types` once):
 *
 *   import type { ZveltioSchema } from './zveltio-types';
 *   const client = createZveltioClient<ZveltioSchema>({ baseUrl: '...' });
 *   const { data } = await client.collection('products').list();
 *   //          ^-- typed as your Products interface
 *
 * Usage without types (untyped, same as before):
 *   const client = createZveltioClient({ baseUrl: '...' });
 */
export declare class ZveltioClient<Schema extends Record<string, any> = Record<string, any>> {
    private baseUrl;
    private headers;
    constructor(config: ZveltioClientConfig);
    private request;
    get<T = any>(path: string): Promise<T>;
    post<T = any>(path: string, body?: unknown): Promise<T>;
    patch<T = any>(path: string, body?: unknown): Promise<T>;
    delete<T = any>(path: string): Promise<T>;
    upload<T = any>(path: string, formData: FormData): Promise<T>;
    /**
     * Returns a fully-typed collection reference.
     * If Schema is provided (via createZveltioClient<MySchema>()),
     * the return type reflects the collection's record shape.
     */
    collection<K extends keyof Schema & string>(name: K): CollectionRef<Schema[K]>;
    collection(name: string): CollectionRef<Record<string, any>>;
    /** Auth helpers */
    readonly auth: {
        readonly login: (email: string, password: string) => Promise<any>;
        readonly signup: (email: string, password: string, name: string) => Promise<any>;
        readonly logout: () => Promise<any>;
        readonly session: () => Promise<any>;
    };
    /** Storage helpers */
    readonly storage: {
        readonly upload: (file: File, folder?: string) => Promise<any>;
        readonly list: (folder?: string) => Promise<any>;
        readonly delete: (key: string) => Promise<any>;
    };
}
export declare function createZveltioClient<Schema extends Record<string, any> = Record<string, any>>(config: ZveltioClientConfig): ZveltioClient<Schema>;
export {};
//# sourceMappingURL=client.d.ts.map