import { EventEmitter } from './event-emitter.js';
import type { GraphQLClient, OpenSpaceResult } from './graphql.js';
import type { RestClient } from './rest.js';
import { ConversationHandle } from './space-session.js';
import { RoolWebDAV, type SpaceFileStorageUsage } from './webdav.js';
import type { AuthManager } from './auth.js';
import type { Logger } from './logger.js';
import type { SpaceRouter, RouteInfo } from './router.js';
import type { RoolClientInfo } from './client-info.js';
import type { RoolObject, GetObjectsResult, RoolSpaceEvents, RoolUserRole, PromptOptions, UpdateObjectOptions, MoveObjectOptions, Conversation, ConversationVisibility, SpaceSchema, CollectionDef, FieldDef, CollectionOptions, InviteRole, SpaceInvite, SpaceInviteCreated, SpaceMember, ConnectionState } from './types.js';
export interface SpaceConfig {
    id: string;
    openSpaceResult: OpenSpaceResult;
    graphqlClient: GraphQLClient;
    restClient: RestClient;
    authManager: AuthManager;
    router: SpaceRouter;
    initialRoute: RouteInfo;
    logger: Logger;
    clientInfo: RoolClientInfo;
    onClose: () => void;
}
/** An imperative API handle for one open space. */
export declare class RoolSpace extends EventEmitter<RoolSpaceEvents> {
    private _id;
    private _openSpaceResult;
    private _connectionState;
    private _closed;
    private _graphqlClient;
    private _restClient;
    private _webdav;
    private _logger;
    private authManager;
    private router;
    private _route;
    private onCloseCallback;
    private clientInfo;
    private subscriptionManager;
    constructor(config: SpaceConfig);
    get id(): string;
    get name(): string;
    get role(): RoolUserRole;
    get isReadOnly(): boolean;
    get memberCount(): number;
    get openSpaceResult(): OpenSpaceResult;
    get connectionState(): ConnectionState;
    get route(): RouteInfo;
    get webdav(): RoolWebDAV;
    refresh(): Promise<OpenSpaceResult>;
    listConversations(): Promise<import("./types.js").ConversationMeta[]>;
    conversation(conversationId: string): ConversationHandle;
    getConversation(conversationId: string): Promise<Conversation | null>;
    deleteConversation(conversationId: string): Promise<void>;
    createConversation(agent: string, visibility: ConversationVisibility): Promise<string>;
    listAgents(): Promise<string[]>;
    deleteAgent(agent: string): Promise<void>;
    canUndo(): Promise<boolean>;
    canRedo(): Promise<boolean>;
    undo(): Promise<boolean>;
    redo(): Promise<boolean>;
    private davHeaders;
    private readObject;
    /** Get an object JSON file by machine path. Fetches from the server on each call. */
    getObject(path: string): Promise<RoolObject | undefined>;
    /** Get object JSON files by machine path in bulk. Duplicate paths are fetched once. */
    getObjects(paths: string[]): Promise<GetObjectsResult>;
    /** Create or replace an object JSON file. */
    putObject(path: string, body: Record<string, unknown>): Promise<{
        object: RoolObject;
        message: string;
    }>;
    /** Patch an existing object JSON file. */
    patchObject(path: string, options: UpdateObjectOptions): Promise<{
        object: RoolObject;
        message: string;
    }>;
    /** Move (rename/relocate) an object. */
    moveObject(from: string, to: string, options?: MoveObjectOptions): Promise<{
        object: RoolObject;
        message: string;
    }>;
    /** Delete object JSON files by path. */
    deleteObjects(paths: string[]): Promise<void>;
    /**
     * Read space metadata from `/space/.meta.json`. Returns `{}` when the space has
     * no metadata file yet. Stateless — callers (e.g. a reactive wrapper) cache and
     * re-fetch this on their own schedule, typically when a file-tree sync reports
     * the node changed.
     */
    readMeta(): Promise<Record<string, unknown>>;
    /**
     * Write the full metadata blob to `/space/.meta.json`, attributed to a
     * conversation. Callers compose the blob (e.g. read-merge-write) — this does no
     * merging.
     */
    writeMeta(meta: Record<string, unknown>): Promise<void>;
    /**
     * Read the collection schema: one `/space/<name>/.schema.json` per collection
     * directory under `/space`. Returns `{}` for a space with no collections.
     * Stateless — reactive callers re-fetch when a `.schema.json` node changes.
     */
    readSchema(): Promise<SpaceSchema>;
    /** Create a new collection (MKCOL + schema JSON). */
    createCollection(name: string, fields: FieldDef[] | CollectionDef, options?: CollectionOptions): Promise<CollectionDef>;
    /** Alter an existing collection's schema JSON. */
    alterCollection(name: string, fields: FieldDef[] | CollectionDef, options?: CollectionOptions): Promise<CollectionDef>;
    /** Drop a collection (DELETE). */
    dropCollection(name: string): Promise<void>;
    /** @internal */
    _updateConversation(conversationId: string, options: {
        name?: string;
        systemInstruction?: string | null;
    }): Promise<void>;
    /** @internal */
    _prompt(prompt: string, conversationId: string, options: PromptOptions | undefined): Promise<{
        message: string;
        objects: RoolObject[];
        creditsUsed: number;
    }>;
    /**
     * Stop whatever is running in a conversation. A conversation processes one
     * run at a time, so no interaction handle is needed.
     *
     * Returns whether anything was actually running.
     */
    stopConversation(conversationId: string): Promise<boolean>;
    /**
     * Fetch an external URL via the server proxy, bypassing CORS restrictions.
     */
    fetch(url: string, init?: {
        method?: string;
        headers?: Record<string, string>;
        body?: unknown;
    }): Promise<Response>;
    private uploadAttachment;
    getStorageUsage(): Promise<SpaceFileStorageUsage>;
    fetchPath(path: string, options?: {
        range?: string | {
            start: number;
            end?: number;
        };
        signal?: AbortSignal;
    }): Promise<Response>;
    rename(newName: string): Promise<void>;
    delete(): Promise<void>;
    listUsers(): Promise<SpaceMember[]>;
    setUserRole(userId: string, role: InviteRole): Promise<void>;
    removeUser(userId: string): Promise<void>;
    createInvite(role: InviteRole, options?: {
        email?: string;
        expiresInDays?: number;
        maxUses?: number;
    }): Promise<SpaceInviteCreated>;
    listInvites(): Promise<SpaceInvite[]>;
    revokeInvite(inviteId: string): Promise<boolean>;
    exportArchive(): Promise<Blob>;
    close(): void;
    private startSubscription;
    private reroute;
    private handleSpaceEvent;
}
//# sourceMappingURL=space.d.ts.map