userdo/dist/src/UserDO.d.ts

A Durable Object base class for building applications on Cloudflare Workers.

import { DurableObject } from 'cloudflare:workers';
import { z } from 'zod';
import { UserDODatabase, TableOptions } from './database/index.js';
declare const UserSchema: z.ZodObject<{
    id: z.ZodString;
    email: z.ZodString;
    passwordHash: z.ZodString;
    salt: z.ZodString;
    createdAt: z.ZodString;
    refreshTokens: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    createdAt: string;
    id: string;
    email: string;
    passwordHash: string;
    salt: string;
    refreshTokens: string[];
}, {
    createdAt: string;
    id: string;
    email: string;
    passwordHash: string;
    salt: string;
    refreshTokens?: string[] | undefined;
}>;
type User = z.infer<typeof UserSchema>;
declare const OrganizationSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    ownerId: z.ZodString;
    createdAt: z.ZodString;
}, "strip", z.ZodTypeAny, {
    createdAt: string;
    id: string;
    name: string;
    ownerId: string;
}, {
    createdAt: string;
    id: string;
    name: string;
    ownerId: string;
}>;
declare const OrganizationMemberSchema: z.ZodObject<{
    id: z.ZodString;
    organizationId: z.ZodString;
    userId: z.ZodString;
    email: z.ZodString;
    role: z.ZodEnum<["admin", "member"]>;
    createdAt: z.ZodString;
}, "strip", z.ZodTypeAny, {
    createdAt: string;
    id: string;
    email: string;
    organizationId: string;
    userId: string;
    role: "admin" | "member";
}, {
    createdAt: string;
    id: string;
    email: string;
    organizationId: string;
    userId: string;
    role: "admin" | "member";
}>;
declare const OrganizationMembershipSchema: z.ZodObject<{
    organizationId: z.ZodString;
    organizationName: z.ZodString;
    ownerEmail: z.ZodString;
    role: z.ZodEnum<["admin", "member"]>;
    joinedAt: z.ZodString;
}, "strip", z.ZodTypeAny, {
    organizationId: string;
    role: "admin" | "member";
    organizationName: string;
    ownerEmail: string;
    joinedAt: string;
}, {
    organizationId: string;
    role: "admin" | "member";
    organizationName: string;
    ownerEmail: string;
    joinedAt: string;
}>;
type Organization = z.infer<typeof OrganizationSchema>;
type OrganizationMember = z.infer<typeof OrganizationMemberSchema>;
type OrganizationMembership = z.infer<typeof OrganizationMembershipSchema>;
export interface Env {
    JWT_SECRET: string;
    USERDO: DurableObjectNamespace<UserDO>;
    ASSETS?: Fetcher;
}
export declare function hashEmailForId(email: string): Promise<string>;
export declare function getUserDO<T extends UserDO>(namespace: DurableObjectNamespace<T>, email: string): T;
export declare function migrateUserEmail({ env, oldEmail, newEmail }: {
    env: Env;
    oldEmail: string;
    newEmail: string;
}): Promise<{
    ok: boolean;
    error?: string;
}>;
export declare class UserDO extends DurableObject {
    protected state: DurableObjectState;
    protected storage: DurableObjectStorage;
    protected env: Env;
    protected database: UserDODatabase;
    protected ownedOrganizations: any;
    protected organizationMembers: any;
    constructor(state: DurableObjectState, env: Env);
    private checkRateLimit;
    private generateTokens;
    signup({ email, password }: {
        email: string;
        password: string;
    }): Promise<{
        user: User;
        token: string;
        refreshToken: string;
    }>;
    login({ email, password }: {
        email: string;
        password: string;
    }): Promise<{
        user: User;
        token: string;
        refreshToken: string;
    }>;
    raw(): Promise<User>;
    init(user: User): Promise<{
        ok: boolean;
    }>;
    deleteUser(): Promise<{
        ok: boolean;
    }>;
    changePassword({ oldPassword, newPassword }: {
        oldPassword: string;
        newPassword: string;
    }): Promise<{
        ok: boolean;
    }>;
    resetPassword({ newPassword }: {
        newPassword: string;
    }): Promise<{
        ok: boolean;
    }>;
    generatePasswordResetToken(): Promise<{
        resetToken: string;
    }>;
    resetPasswordWithToken({ resetToken, newPassword }: {
        resetToken: string;
        newPassword: string;
    }): Promise<{
        ok: boolean;
    }>;
    verifyToken({ token }: {
        token: string;
    }): Promise<{
        ok: boolean;
        user?: {
            id: string;
            email: string;
        };
        error?: string;
    }>;
    set(key: string, value: unknown): Promise<{
        ok: boolean;
    }>;
    get(key: string): Promise<unknown>;
    refreshToken({ refreshToken }: {
        refreshToken: string;
    }): Promise<{
        token: string;
    }>;
    revokeRefreshToken({ refreshToken }: {
        refreshToken: string;
    }): Promise<{
        ok: boolean;
    }>;
    revokeAllRefreshTokens(): Promise<{
        ok: boolean;
    }>;
    logout(): Promise<{
        ok: boolean;
    }>;
    setOrganizationContext(organizationId?: string): void;
    createOrganization(name: string): Promise<{
        organization: Organization;
    }>;
    getOrganizations(): Promise<{
        organizations: Organization[];
        memberOrganizations: OrganizationMembership[];
    }>;
    getOrganization(organizationId: string): Promise<{
        organization: Organization;
        members: OrganizationMember[];
        isOwner: boolean;
    }>;
    getOwnedOrganization(organizationId: string): Promise<{
        organization: Organization;
        members: OrganizationMember[];
    }>;
    addOrganizationMember(organizationId: string, email: string, role?: 'admin' | 'member'): Promise<{
        member: OrganizationMember;
    }>;
    addMembership(membership: OrganizationMembership): Promise<void>;
    removeOrganizationMember(organizationId: string, userId: string): Promise<{
        ok: boolean;
    }>;
    removeMembership(organizationId: string): Promise<void>;
    private findUserDONamespace;
    table<T extends z.ZodSchema>(name: string, schema: T, options?: TableOptions): import("./server.js").GenericTable<z.TypeOf<T>>;
    get db(): SqlStorage;
    protected getCurrentUserId(): string;
    fetch(request: Request): Promise<Response>;
    webSocketMessage(ws: WebSocket, message: ArrayBuffer | string): Promise<void>;
    webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void>;
    protected broadcast(event: string, data: any): void;
}
declare const _default: {};
export default _default;