import { SdkAuthResult, AuthResult, RegisterInput, RegistrationResult, MessageResult, ProjectInvitationPreview, ProjectMember, AppNotesUser, ProjectAccess, AppNotesRole, ProjectInvitation, ProjectInviteLink, RoomAccessRule, AppNotesProject, ThreadListScope, AppNotesThread, ThreadUnreadSummary, CreateThreadInput as CreateThreadInput$1, UpdateThreadInput, AppNotesComment, AppNotesAttachment } from '@appnotes/contracts';
export { AppNotesAttachment, AppNotesComment, AppNotesProject, AppNotesRole, AppNotesThread, AppNotesUser, AuthResult, MessageResult, ProjectAccess, ProjectInvitation, ProjectInvitationPreview, ProjectInviteLink, ProjectMember, RegisterInput, RegistrationResult, RoomAccessRule, SdkAuthResult, ThreadUnreadSummary, UpdateThreadInput } from '@appnotes/contracts';

type CreateThreadInput = Omit<CreateThreadInput$1, "projectKey">;
type ThreadScope = ThreadListScope;
type AppNotesClientOptions<Session extends SdkAuthResult = AuthResult> = {
    baseUrl: string;
    projectKey: string;
    getAccessToken?: () => string | null | Promise<string | null>;
    getRefreshToken?: () => string | null | Promise<string | null>;
    onSessionRefresh?: (session: Session) => void | Promise<void>;
    credentials?: RequestCredentials;
    authenticationScope?: "global" | "project";
    refreshMode?: "token" | "cookie";
    fetch?: typeof globalThis.fetch;
};
type AppNotesIntegrationClientOptions = {
    baseUrl: string;
    projectKey: string;
    apiKey: string;
    fetch?: typeof globalThis.fetch;
};
declare class AppNotesApiError extends Error {
    readonly status: number;
    readonly details: unknown;
    constructor(status: number, message: string, details?: unknown);
}
type AppNotesHttpTransportOptions = {
    baseUrl: string;
    credentials?: RequestCredentials;
    fetch?: typeof globalThis.fetch;
};
declare class AppNotesHttpTransport {
    private readonly baseUrl;
    private readonly credentials?;
    private readonly requestFetch;
    constructor(options: AppNotesHttpTransportOptions);
    assetUrl(path: string | null | undefined): string | null;
    request<T>(path: string, options?: RequestInit & {
        accessToken?: string;
        responseType?: "json" | "blob";
    }): Promise<T>;
}
declare class AppNotesClient<Session extends SdkAuthResult = AuthResult> {
    private readonly projectKey;
    private readonly getAccessToken?;
    private readonly getRefreshToken?;
    private readonly onSessionRefresh?;
    private readonly authenticationScope;
    private readonly refreshMode;
    private readonly transport;
    private refreshPromise;
    private lastRefreshedSession;
    constructor(options: AppNotesClientOptions<Session>);
    assetUrl(path: string | null | undefined): string | null;
    login(email: string, password: string, otp?: string): Promise<Session>;
    refresh(refreshToken: string): Promise<Session>;
    register(input: RegisterInput): Promise<RegistrationResult>;
    verifyEmail(token: string): Promise<Session & {
        projectKey: string;
    }>;
    resendEmailVerification(email: string): Promise<MessageResult>;
    requestPasswordReset(email: string): Promise<MessageResult>;
    resetPassword(token: string, password: string): Promise<MessageResult>;
    getProjectInvitation(token: string): Promise<{
        invitation: ProjectInvitationPreview;
    }>;
    acceptProjectInvitation(token: string): Promise<{
        member: ProjectMember;
    }>;
    me(): Promise<{
        user: AppNotesUser;
    }>;
    logout(): Promise<void>;
    listProjects(): Promise<{
        projects: ProjectAccess[];
    }>;
    createProject(name: string): Promise<ProjectAccess>;
    getProject(): Promise<ProjectAccess>;
    listProjectMembers(): Promise<{
        members: ProjectMember[];
    }>;
    addProjectMember(email: string, role: Exclude<AppNotesRole, "owner">): Promise<{
        invitation: ProjectInvitation;
    }>;
    createProjectInviteLink(role: Exclude<AppNotesRole, "owner">): Promise<{
        inviteLink: ProjectInviteLink;
    }>;
    updateProjectMemberRole(userId: string, role: Exclude<AppNotesRole, "owner">): Promise<{
        member: ProjectMember;
    }>;
    updateProjectMemberRoomAccess(userId: string, roomAccess: RoomAccessRule): Promise<{
        member: ProjectMember;
    }>;
    removeProjectMember(userId: string): Promise<{
        member: ProjectMember;
    }>;
    updateAllowedOrigins(allowedOrigins: string[]): Promise<{
        project: AppNotesProject;
    }>;
    listThreads(input: {
        roomId: string;
        roomName?: string;
        pageId?: string;
        scope?: ThreadScope;
        search?: string;
        status?: AppNotesThread["status"];
        authorId?: string;
        pageBinding?: "any" | "current" | "unbound";
        cursor?: string;
        limit?: number;
    }): Promise<{
        items: AppNotesThread[];
        authors?: AppNotesUser[];
        nextCursor: string | null;
        unread?: ThreadUnreadSummary;
    }>;
    getThread(threadId: string): Promise<AppNotesThread>;
    markThreadRead(threadId: string, readThrough: string): Promise<AppNotesThread>;
    createThread(input: CreateThreadInput): Promise<AppNotesThread>;
    updateThread(threadId: string, input: UpdateThreadInput): Promise<AppNotesThread>;
    addComment(threadId: string, body: string): Promise<AppNotesComment>;
    uploadAttachment(threadId: string, file: Blob, options?: {
        commentId?: string;
        fileName?: string;
    }): Promise<{
        attachment: AppNotesAttachment;
        thread: AppNotesThread;
    }>;
    deleteAttachment(attachmentId: string): Promise<AppNotesThread>;
    downloadAttachment(attachmentId: string): Promise<Blob>;
    setThreadStatus(threadId: string, status: AppNotesThread["status"]): Promise<AppNotesThread>;
    setThreadPinned(threadId: string, isPinned: boolean): Promise<AppNotesThread>;
    archiveThread(threadId: string): Promise<AppNotesThread>;
    restoreThread(threadId: string): Promise<AppNotesThread>;
    clearArchive(roomId: string): Promise<number>;
    private request;
    private refreshSession;
}
/** Server-side client for the personal API-key integration endpoints. */
declare class AppNotesIntegrationClient {
    private readonly projectKey;
    private readonly apiKey;
    private readonly transport;
    constructor(options: AppNotesIntegrationClientOptions);
    createNote(input: CreateThreadInput): Promise<AppNotesThread>;
    updateNote(noteId: string, input: UpdateThreadInput): Promise<AppNotesThread>;
    addComment(noteId: string, body: string): Promise<AppNotesComment>;
    updateComment(noteId: string, commentId: string, body: string): Promise<AppNotesComment>;
    uploadAttachment(noteId: string, file: Blob, options?: {
        commentId?: string;
        fileName?: string;
    }): Promise<{
        attachment: AppNotesAttachment;
        thread: AppNotesThread;
    }>;
    deleteAttachment(attachmentId: string): Promise<AppNotesThread>;
    downloadAttachment(attachmentId: string): Promise<Blob>;
    private request;
}

export { AppNotesApiError, AppNotesClient, type AppNotesClientOptions, AppNotesHttpTransport, type AppNotesHttpTransportOptions, AppNotesIntegrationClient, type AppNotesIntegrationClientOptions, type CreateThreadInput, type ThreadScope };