@blocklet/js-sdk/dist/index.d.mts

sdk for blocklet development, client only

import * as axios from 'axios';
import { Axios, AxiosRequestConfig } from 'axios';
import { TTheme, TNavigationItem } from '@blocklet/meta/lib/types';
import { TComponentInternalInfo } from '@blocklet/meta/lib/blocklet';
import { BlockletStatus } from '@blocklet/meta/lib/constants';

type UserPublicInfo = {
    avatar: string;
    did: string;
    fullName: string;
    sourceAppPid: string | null;
};
type Webhook = {
    type: 'slack' | 'api';
    url: string;
};
type NotificationConfig = {
    webhooks?: Webhook[];
    notifications?: {
        email?: boolean;
        wallet?: boolean;
        phone?: boolean;
    };
};
type PrivacyConfig = {
    [key: string]: boolean;
};
interface SpaceGateway {
    did: string;
    name: string;
    url: string;
    endpoint: string;
}
declare class AuthService {
    private api;
    constructor({ api }: {
        api: Axios;
    });
    getUserPublicInfo({ did }: {
        did: string;
    }): Promise<UserPublicInfo>;
    getUserPrivacyConfig({ did }: {
        did: string;
    }): Promise<PrivacyConfig>;
    saveUserPrivacyConfig(config: PrivacyConfig): Promise<PrivacyConfig>;
    getUserNotificationConfig(): Promise<NotificationConfig>;
    saveUserNotificationConfig(config: NotificationConfig): Promise<NotificationConfig>;
    testNotificationWebhook(webhook: Webhook): Promise<{
        success: boolean;
    }>;
    getProfileUrl({ did, locale }: {
        did: string;
        locale: string;
    }): Promise<string>;
    getProfile(): Promise<any>;
    refreshProfile(): Promise<void>;
    saveProfile({ locale, inviter, metadata, address, }: {
        locale?: string;
        inviter?: string;
        metadata?: any;
        address?: any;
    }): Promise<any>;
    updateDidSpace({ spaceGateway }: {
        spaceGateway: SpaceGateway;
    }): Promise<void>;
    /**
     * 指定要退出登录的设备 id
     * 指定要退出登录的会话状态
     * @param {{ visitorId: string, status: string }} { visitorId, status }
     * @return {Promise<void>}
     */
    logout({ visitorId, status, includeFederated, }: {
        visitorId?: string;
        status?: string;
        includeFederated?: boolean;
    }): Promise<void>;
    /**
     * 删除当前登录用户
     * @return {Promise<{did: string}>}
     */
    destroyMyself(): Promise<{
        did: string;
    }>;
}

declare class TokenService {
    getSessionToken(config: any): string;
    setSessionToken(value: string): void;
    removeSessionToken(): void;
    getRefreshToken(): string;
    setRefreshToken(value: string): void;
    removeRefreshToken(): void;
}

type RequestParams = {
    lazy?: boolean;
    lazyTime?: number;
    componentDid?: string;
};
type BlockletComponent = TComponentInternalInfo & {
    status: keyof typeof BlockletStatus;
};
type BlockletSettings = {
    session: {
        ttl: number;
        cacheTtl: number;
    };
    federated: {
        master: {
            appId: string;
            appPid: string;
            appName: string;
            appDescription: string;
            appUrl: string;
            appLogo: string;
            version: string;
        };
        config: Record<string, any>;
    };
    oauth: Record<string, {
        enabled: boolean;
        [x: string]: any;
    }>;
};
type Blocklet = {
    [x: string]: any;
    did: string;
    appId: string;
    appPk: string;
    appIds?: string[];
    appPid: string;
    appName: string;
    appDescription: string;
    appLogo: string;
    appLogoRect: string;
    appUrl: string;
    domainAliases?: string[];
    isComponent: boolean;
    prefix: string;
    groupPrefix: string;
    pageGroup: string;
    version: string;
    mode: string;
    tenantMode: 'single' | 'multiple';
    theme: TTheme;
    navigation: TNavigationItem[];
    preferences: Record<string, any>;
    languages: {
        code: string;
        name: string;
    }[];
    passportColor: string;
    componentMountPoints: BlockletComponent[];
    alsoKnownAs: string[];
    trustedFactories: string[];
    status: string;
    serverDid: string;
    serverVersion: string;
    componentId: string;
    webWalletUrl: string;
    updatedAt: number;
    settings: BlockletSettings;
};

declare class BlockletService {
    getBlocklet(): Blocklet;
    getBlocklet(baseUrl?: string, force?: boolean): Promise<Blocklet>;
    loadBlocklet(): Promise<void>;
    getPrefix(blocklet?: Blocklet): string;
}

type UserSessionUser = {
    avatar: string;
    did: string;
    email: string;
    fullName: string;
    pk: string;
    remark?: string;
    role: string;
    roleTitle: string;
    sourceAppPid: string | null;
    sourceProvider: 'wallet' | 'auth0' | 'nft';
};
type UserSession = {
    appName: string;
    appPid: string;
    extra: {
        walletOS: 'android' | 'ios' | 'web';
    };
    id: string;
    lastLoginIp: string;
    passportId: string | null;
    ua: string;
    createdAt?: string;
    updatedAt: string;
    status?: string;
    user?: UserSessionUser;
    userDid: string;
    visitorId: string;
};
type UserSessionList = {
    list: UserSession[];
    paging: {
        page: number;
        pageSize: number;
        total: number;
    };
};
type UserSessionQuery = {
    page: number;
    pageSize: number;
    status?: 'online' | 'expired' | 'offline';
};
declare class UserSessionService {
    private api;
    private blocklet;
    constructor({ api, blocklet }: {
        api: Axios;
        blocklet?: BlockletService;
    });
    getBaseUrl(appUrl?: string): string | undefined;
    getUserSessions({ did, appUrl }: {
        did: string;
        appUrl?: string;
    }): Promise<UserSession[]>;
    /**
     * 获取个人的所有登录会话
     */
    getMyLoginSessions({ appUrl }?: {
        appUrl?: string;
    }, params?: UserSessionQuery): Promise<UserSessionList>;
    loginByUserSession({ id, appPid, userDid, passportId, appUrl, }: {
        appPid: string;
        userDid: string;
        id: string;
        passportId: string;
        appUrl?: string;
    }): Promise<UserSession[]>;
}

declare class ComponentService {
    private blocklet;
    constructor({ blocklet }?: {
        blocklet?: Blocklet;
    });
    getComponent(name: string): never;
    getComponentMountPoint(name?: string): string;
    getUrl(name: string, ...parts: string[]): string;
}

type AppInfo = {
    appId: string;
    appName: string;
    appDescription: string;
    appLogo: string;
    appPid: string;
    appUrl: string;
    version: string;
    sourceAppPid: string;
    provider: string;
};
type ServerInfo = {
    appId: string;
    appName: string;
    appDescription: string;
    appUrl: string;
    sourceAppPid: string;
    provider: string;
    type: 'server';
};
declare class FederatedService {
    private api;
    private blocklet;
    private blockletDataCache;
    constructor({ api, blocklet }: {
        api: Axios;
        blocklet?: BlockletService;
    });
    getTrustedDomains(): Promise<Array<string>>;
    getMaster(blocklet?: Blocklet): {
        appId: string;
        appPid: string;
        appName: string;
        appDescription: string;
        appUrl: string;
        appLogo: string;
        version: string;
    };
    getConfig(blocklet?: Blocklet): Record<string, any>;
    getFederatedEnabled(blocklet?: Blocklet): boolean;
    getSourceAppPid(blocklet?: Blocklet): string;
    getFederatedApp(blocklet?: Blocklet): AppInfo | null;
    getCurrentApp(blocklet?: Blocklet): AppInfo | ServerInfo;
    getApps(blocklet?: Blocklet): any[];
    getBlockletData(appUrl: string, force?: boolean): Promise<any>;
}

declare function getCSRFToken(): string;

declare class BlockletSDK {
    api: Axios;
    user: AuthService;
    userSession: UserSessionService;
    token: TokenService;
    blocklet: BlockletService;
    federated: FederatedService;
    constructor();
}
declare function createAxios(config?: AxiosRequestConfig, requestParams?: RequestParams): axios.AxiosInstance;
declare function createFetch(options?: RequestInit, requestParams?: RequestParams): (input: string | Request | URL, options?: RequestInit & {
    secure?: boolean;
}) => Promise<Response>;
declare const getBlockletSDK: () => BlockletSDK;

export { AuthService, BlockletSDK, BlockletService, ComponentService, FederatedService, type NotificationConfig, type PrivacyConfig, type SpaceGateway, TokenService, type UserPublicInfo, type UserSession, type UserSessionList, type UserSessionQuery, UserSessionService, type UserSessionUser, type Webhook, createAxios, createFetch, getBlockletSDK, getCSRFToken };