@ray-js/lock-sdk 1.1.3 → 1.2.0-beta.1

package/lib/feature/password/temporary/freeze-rename.js

@@ -0,0 +1,72 @@
+import { fetchEffectiveList, reNameOffline, reNameTemporary, } from "../../../api/temp";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { changePasswordPhaseForRuntime } from "./internal/change-password-phase";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function freezeTempForRuntime(rt, params) {
+    sdkLog("info", "tempPassword", "freezeStart", {
+        devId: rt.devId,
+        data: { hasBindingId: !!params.unlockBindingId },
+    });
+    return changePasswordPhaseForRuntime(rt, params.unlockBindingId, 4);
+}
+export async function unfreezeTempForRuntime(rt, params) {
+    sdkLog("info", "tempPassword", "unfreezeStart", {
+        devId: rt.devId,
+        data: { hasBindingId: !!params.unlockBindingId },
+    });
+    return changePasswordPhaseForRuntime(rt, params.unlockBindingId, 2);
+}
+export async function renameTempForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "renameStart", {
+        devId: rt.devId,
+        data: {
+            hasBindingId: !!params.unlockBindingId,
+            hasName: typeof params.name === "string",
+        },
+    });
+    const list = await fetchEffectiveList({
+        devId: rt.config.devInfo.devId,
+        authTypes: ["LOCK_OFFLINE_TEMP_PWD", "LOCK_TEMP_PWD"],
+    });
+    const password = list.find((item) => item.unlockBindingId === params.unlockBindingId);
+    if (!password) {
+        const error = getError(1051);
+        sdkLog("warn", "tempPassword", "renamePasswordNotFound", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+    try {
+        if (password.opModeType === 1) {
+            await reNameTemporary({
+                devId: rt.config.devInfo.devId,
+                unlockBindingId: params.unlockBindingId,
+                name: params.name,
+            });
+        }
+        else {
+            await reNameOffline({
+                devId: rt.config.devInfo.devId,
+                unlockBindingId: params.unlockBindingId,
+                pwdName: params.name,
+            });
+        }
+        sdkLog("info", "tempPassword", "renameSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { opModeType: password.opModeType },
+        });
+    }
+    catch (e) {
+        sdkLog("error", "tempPassword", "renameFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { opModeType: password.opModeType },
+            error: e,
+        });
+        throw handleCloudError(e);
+    }
+}

package/lib/feature/password/temporary/internal/change-password-phase.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../../../runtime/LockDeviceRuntime";
+export declare function changePasswordPhaseForRuntime(rt: LockDeviceRuntime, unlockBindingId: string, phase: number): Promise<boolean>;

package/lib/feature/password/temporary/internal/change-password-phase.js

@@ -0,0 +1,48 @@
+import { fetchEffectiveList, updateTemporaryPassword, } from "../../../../api/temp";
+import { getError, handleCloudError } from "../../../../utils/errors";
+import { sdkLog } from "../../../../utils/sdk-log";
+export async function changePasswordPhaseForRuntime(rt, unlockBindingId, phase) {
+    const startedAt = Date.now();
+    const list = await fetchEffectiveList({
+        devId: rt.config.devInfo.devId,
+        authTypes: ["LOCK_OFFLINE_TEMP_PWD", "LOCK_TEMP_PWD"],
+    });
+    const password = list.find((item) => item.unlockBindingId === unlockBindingId);
+    if (!password) {
+        const error = getError(1051);
+        sdkLog("warn", "tempPassword", "changePhasePasswordNotFound", {
+            devId: rt.devId,
+            data: { phase },
+            error,
+        });
+        throw error;
+    }
+    try {
+        await updateTemporaryPassword({
+            unlockBindingId,
+            schedule: password.scheduleDetails,
+            effectiveTime: password.effectiveTime,
+            invalidTime: password.invalidTime,
+            name: password.name,
+            phase,
+            symbolic: false,
+            dpTunnel: 2,
+            devId: rt.config.devInfo.devId,
+        });
+        sdkLog("info", "tempPassword", "changePhaseSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { phase },
+        });
+    }
+    catch (e) {
+        sdkLog("error", "tempPassword", "changePhaseFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { phase },
+            error: e,
+        });
+        throw handleCloudError(e);
+    }
+    return true;
+}

package/lib/feature/password/temporary/internal/constants.d.ts

@@ -0,0 +1,12 @@
+import type { TemporaryPasswordType } from "../../../../interface";
+import type { OfflinePasswordType } from "../types";
+export declare const PASSWORD_REGEX: RegExp;
+export declare const passwordTypeMap: Record<string, TemporaryPasswordType>;
+export declare const onLinePasswordStatusMap: {
+    readonly 1: "effective";
+    readonly 2: "synchronizing";
+    readonly 3: "expired";
+    readonly 4: "disabled";
+    readonly 5: "invalid";
+};
+export declare const offlinePasswordTypeMap: Record<OfflinePasswordType, string>;

package/lib/feature/password/temporary/internal/constants.js

@@ -0,0 +1,21 @@
+export const PASSWORD_REGEX = /^[0-9]+$/;
+export const passwordTypeMap = {
+    "1-0": "custom",
+    "3-1": "once",
+    "3-0": "limit",
+    "3-8": "clearOne",
+    "3-9": "clear",
+};
+export const onLinePasswordStatusMap = {
+    1: "effective",
+    2: "synchronizing",
+    3: "expired",
+    4: "disabled",
+    5: "invalid",
+};
+export const offlinePasswordTypeMap = {
+    once: "1",
+    multiple: "0",
+    clear_one: "8",
+    clear_all: "9",
+};

package/lib/feature/password/temporary/internal/password-helpers.d.ts

@@ -0,0 +1,4 @@
+import { type CreateOfflinePasswordParams, type ValidateTempPwdParams } from "../../../../api/temp";
+export declare const PASSWORD_REGEX: RegExp;
+export declare function isValidPassword(params: ValidateTempPwdParams): Promise<boolean>;
+export declare function getOfflinePassword(params: CreateOfflinePasswordParams): Promise<import("../../../../api/temp").OfflinePwdResult>;

package/lib/feature/password/temporary/internal/password-helpers.js

@@ -0,0 +1,18 @@
+import { createOfflinePassword, validateTempPwd, } from "../../../../api/temp";
+import { handleCloudError } from "../../../../utils/errors";
+export const PASSWORD_REGEX = /^[0-9]+$/;
+export async function isValidPassword(params) {
+    const validateResult = await validateTempPwd(params);
+    if (!validateResult.valid) {
+        handleCloudError({ innerError: { errorCode: validateResult.errorCode } });
+    }
+    return true;
+}
+export async function getOfflinePassword(params) {
+    try {
+        return await createOfflinePassword(params);
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/password/temporary/internal/password-type-map.d.ts

@@ -0,0 +1,2 @@
+import type { TemporaryPasswordType } from "../../../../interface";
+export declare const PASSWORD_TYPE_MAP: Record<string, TemporaryPasswordType>;

package/lib/feature/password/temporary/internal/password-type-map.js

@@ -0,0 +1,7 @@
+export const PASSWORD_TYPE_MAP = {
+    "1-0": "custom",
+    "3-1": "once",
+    "3-0": "limit",
+    "3-8": "clearOne",
+    "3-9": "clear",
+};

package/lib/feature/password/temporary/lists.d.ts

@@ -0,0 +1,16 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { EffectivePasswrodItem, GetInvalidListParams, InvalidPasswordItem } from "./types";
+export declare function getTempEffectiveListForRuntime(rt: LockDeviceRuntime): Promise<EffectivePasswrodItem[]>;
+export declare function getTempInvalidListForRuntime(rt: LockDeviceRuntime, params?: GetInvalidListParams): Promise<{
+    list: InvalidPasswordItem[];
+    hasMore: boolean;
+    total: number;
+}>;
+export declare function clearTempInvalidListForRuntime(rt: LockDeviceRuntime): Promise<boolean>;
+export interface LimitTempItem {
+    id: string;
+    name: string;
+    effectiveTime: number;
+    invalidTime: number;
+}
+export declare function getTempLimitListForClearForRuntime(rt: LockDeviceRuntime): Promise<LimitTempItem[]>;

package/lib/feature/password/temporary/lists.js

@@ -0,0 +1,157 @@
+import { clearInvalidTempList, fetchEffectiveList, fetchInvalidList, getLimitOfflinePwdListForClear, } from "../../../api/temp";
+import { parseWeek } from "../../../utils";
+import { handleCloudError } from "../../../utils/errors";
+import { PASSWORD_TYPE_MAP } from "./internal/password-type-map";
+export async function getTempEffectiveListForRuntime(rt) {
+    const res = await fetchEffectiveList({
+        devId: rt.config.devInfo.devId,
+        authTypes: ["LOCK_OFFLINE_TEMP_PWD", "LOCK_TEMP_PWD"],
+    });
+    return res.map((item) => {
+        const type = PASSWORD_TYPE_MAP[`${item.opModeType}-${item.opModeSubType}`] || "custom";
+        let status = "synchronizing";
+        switch (item.phase) {
+            case 1:
+                status = "effective";
+                if (item.effective === 1) {
+                    status = "toBeEffective";
+                }
+                break;
+            case 2:
+                status = "synchronizing";
+                break;
+            case 3:
+                status = "frozen";
+                break;
+            case 4:
+                status = "freezing";
+                break;
+            case 9:
+                status = "toBeDeleted";
+                break;
+            case 10:
+                status = "synchronizing";
+                break;
+        }
+        const effectiveConfig = {
+            effectiveDate: item.effectiveTime,
+            expiredDate: item.invalidTime,
+        };
+        if (item.scheduleDetails?.length) {
+            const scheduleDetail = item.scheduleDetails[0];
+            effectiveConfig.repeat =
+                scheduleDetail.allDay === false ? "week" : "none";
+            if (effectiveConfig.repeat === "week") {
+                effectiveConfig.weeks = parseWeek(scheduleDetail.workingDay);
+                effectiveConfig.effectiveTime = scheduleDetail.effectiveTime;
+                effectiveConfig.expiredTime = scheduleDetail.invalidTime;
+            }
+        }
+        const data = {
+            unlockBindingId: item.unlockBindingId,
+            name: item.name,
+            status,
+            type,
+            sn: item.sn,
+            hasClearPwd: item.opModeInfo?.hasClearPwd === true,
+            effectiveConfig,
+        };
+        if (data.type === "clearOne") {
+            data.clearInfo = {
+                name: item.opModeInfo?.revokedPwdName || "",
+                effectiveConfig: {
+                    effectiveDate: item.opModeInfo?.revokedPwdEffectiveTime || 0,
+                    expiredDate: item.opModeInfo?.revokedPwdInvalidTime || 0,
+                },
+            };
+        }
+        return data;
+    });
+}
+export async function getTempInvalidListForRuntime(rt, params) {
+    const res = await fetchInvalidList({
+        devId: rt.config.devInfo.devId,
+        offset: (params?.page || 1) - 1,
+        limit: params?.pageSize || 200,
+    });
+    const list = res.datas.map((item) => {
+        const type = PASSWORD_TYPE_MAP[`${item.opModeType}-${item.opModeSubType}`] || "custom";
+        let status = "expired";
+        let invalidReason = "synchronizationFailed";
+        if (item.phase === 8) {
+            invalidReason = "deleted";
+        }
+        if (item.failReason) {
+            switch (item.phase) {
+                case 1:
+                    invalidReason = "synchronizationFailed";
+                    break;
+                case 2:
+                    invalidReason = "passwordFull";
+                    break;
+            }
+        }
+        const effectiveConfig = {
+            effectiveDate: item.effectiveTime,
+            expiredDate: item.invalidTime,
+        };
+        if (item.scheduleDetails?.length) {
+            const scheduleDetail = item.scheduleDetails[0];
+            effectiveConfig.repeat =
+                scheduleDetail.allDay === false ? "week" : "none";
+            if (effectiveConfig.repeat === "week") {
+                effectiveConfig.weeks = parseWeek(scheduleDetail.workingDay);
+                effectiveConfig.effectiveTime = scheduleDetail.effectiveTime;
+                effectiveConfig.expiredTime = scheduleDetail.invalidTime;
+            }
+        }
+        const data = {
+            unlockBindingId: item.unlockBindingId,
+            name: item.name,
+            invalidReason,
+            status,
+            type,
+            sn: item.sn,
+            hasClearPwd: item.opModeInfo?.hasClearPwd === true,
+            effectiveConfig,
+        };
+        if (data.type === "clearOne") {
+            data.clearInfo = {
+                name: item.opModeInfo?.revokedPwdName || "",
+                effectiveConfig: {
+                    effectiveDate: item.opModeInfo?.revokedPwdEffectiveTime || 0,
+                    expiredDate: item.opModeInfo?.revokedPwdInvalidTime || 0,
+                },
+            };
+        }
+        return data;
+    });
+    return {
+        list,
+        hasMore: res.hasNext,
+        total: res.totalCount,
+    };
+}
+export async function clearTempInvalidListForRuntime(rt) {
+    try {
+        return await clearInvalidTempList({
+            devId: rt.config.devInfo.devId,
+        });
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}
+export async function getTempLimitListForClearForRuntime(rt) {
+    const res = await getLimitOfflinePwdListForClear({
+        devId: rt.devId,
+    });
+    return res.map((item) => {
+        return {
+            id: item.unlockBindingId,
+            name: item.pwdName,
+            effectiveTime: Number(item.gmtStart),
+            invalidTime: Number(item.gmtExpired),
+        };
+    });
+}

package/lib/feature/password/temporary/offline-create.d.ts

@@ -0,0 +1,7 @@
+import type { TempPasswordResult } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { CreateClearParams, CreateLimitParams, CreateOnceParams } from "./types";
+export declare function createTempLimitForRuntime(rt: LockDeviceRuntime, params: CreateLimitParams): Promise<TempPasswordResult>;
+export declare function createTempOnceForRuntime(rt: LockDeviceRuntime, params: CreateOnceParams): Promise<TempPasswordResult>;
+export declare function createTempDynamicForRuntime(rt: LockDeviceRuntime): Promise<TempPasswordResult>;
+export declare function createTempClearForRuntime(rt: LockDeviceRuntime, params: CreateClearParams): Promise<TempPasswordResult>;

package/lib/feature/password/temporary/offline-create.js

@@ -0,0 +1,192 @@
+import { getDynamicPassword, revokeOfflinePassword, } from "../../../api/temp";
+import { parseOfflinePasswordForRuntime } from "../../utils";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { getOfflinePassword } from "./internal/password-helpers";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function createTempLimitForRuntime(rt, params) {
+    const { name, effectiveTime, invalidTime } = params;
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createOfflineLimitStart", {
+        devId: rt.devId,
+        data: { hasName: typeof name === "string" },
+    });
+    if (name && name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "tempPassword", "createOfflineLimitInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: name.length },
+            error,
+        });
+        throw error;
+    }
+    if (effectiveTime >= invalidTime) {
+        const error = getError(1010);
+        sdkLog("warn", "tempPassword", "createOfflineLimitInvalidTime", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    const res = await getOfflinePassword({
+        devId: rt.config.devInfo.devId,
+        pwdType: "0",
+        pwdName: name,
+        gmtStart: effectiveTime,
+        gmtExpired: invalidTime,
+    });
+    sdkLog("info", "tempPassword", "createOfflineLimitSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+    });
+    return {
+        type: "limit",
+        name: res.pwdName,
+        password: parseOfflinePasswordForRuntime(rt, res.pwd),
+        unlockBindingId: res.unlockBindingId,
+        effectiveConfig: {
+            effectiveDate: res.gmtStart,
+            expiredDate: res.gmtExpired,
+        },
+    };
+}
+export async function createTempOnceForRuntime(rt, params) {
+    const { name } = params;
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createOfflineOnceStart", {
+        devId: rt.devId,
+        data: { hasName: typeof name === "string" },
+    });
+    if (name && name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "tempPassword", "createOfflineOnceInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: name.length },
+            error,
+        });
+        throw error;
+    }
+    const res = await getOfflinePassword({
+        devId: rt.config.devInfo.devId,
+        pwdType: "1",
+        pwdName: name,
+        gmtStart: 0,
+        gmtExpired: 0,
+    });
+    sdkLog("info", "tempPassword", "createOfflineOnceSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+    });
+    return {
+        type: "once",
+        name: res.pwdName,
+        password: parseOfflinePasswordForRuntime(rt, res.pwd),
+        unlockBindingId: res.unlockBindingId,
+        effectiveConfig: {
+            effectiveDate: res.gmtStart,
+            expiredDate: res.gmtExpired,
+        },
+    };
+}
+export async function createTempDynamicForRuntime(rt) {
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createDynamicStart", {
+        devId: rt.devId,
+    });
+    try {
+        const { dynamicPassword } = await getDynamicPassword({
+            devId: rt.config.devInfo.devId,
+        });
+        const now = Math.floor(Date.now() / 1000);
+        sdkLog("info", "tempPassword", "createDynamicSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+        return {
+            type: "dynamic",
+            name: "",
+            password: parseOfflinePasswordForRuntime(rt, dynamicPassword),
+            unlockBindingId: "",
+            effectiveConfig: {
+                effectiveDate: now,
+                expiredDate: now + 5 * 60,
+            },
+        };
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "createDynamicFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}
+export async function createTempClearForRuntime(rt, params) {
+    const { name, unlockBindingId, clearAll } = params;
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createClearStart", {
+        devId: rt.devId,
+        data: { clearAll, hasName: typeof name === "string" },
+    });
+    if (name && name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "tempPassword", "createClearInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: name.length },
+            error,
+        });
+        throw error;
+    }
+    if (!clearAll && !unlockBindingId) {
+        const error = getError(1044);
+        sdkLog("warn", "tempPassword", "createClearMissingBinding", {
+            devId: rt.devId,
+            data: { clearAll },
+            error,
+        });
+        throw error;
+    }
+    try {
+        let res;
+        if (clearAll) {
+            res = await getOfflinePassword({
+                devId: rt.config.devInfo.devId,
+                pwdType: "9",
+                pwdName: name,
+                gmtStart: 0,
+                gmtExpired: 0,
+            });
+        }
+        else {
+            res = await revokeOfflinePassword({
+                devId: rt.config.devInfo.devId,
+                name,
+                unlockBindingId: unlockBindingId,
+            });
+        }
+        sdkLog("info", "tempPassword", "createClearSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { clearAll },
+        });
+        return {
+            type: clearAll ? "clear" : "clearOne",
+            name: res.pwdName,
+            password: parseOfflinePasswordForRuntime(rt, res.pwd),
+            unlockBindingId: res.unlockBindingId,
+            effectiveConfig: {
+                effectiveDate: res.gmtStart,
+                expiredDate: res.gmtExpired,
+            },
+        };
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "createClearFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { clearAll },
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/password/temporary/types.d.ts

@@ -0,0 +1,107 @@
+import type { EffectiveConfig, TemporaryPasswordType } from "../../../interface";
+export interface CreateCustomParams {
+    password: string;
+    name?: string;
+    effective: EffectiveConfig;
+}
+export interface RemoveCustomProps {
+    unlockBindingId: string;
+    sn: number;
+}
+export interface UpdateTempPasswordParams {
+    unlockBindingId: string;
+    name: string;
+    effective: EffectiveConfig;
+}
+export interface CreateLimitParams {
+    name: string;
+    effectiveTime: number;
+    invalidTime: number;
+}
+export interface CreateOnceParams {
+    name?: string;
+}
+export interface CreateClearParams {
+    name?: string;
+    unlockBindingId?: string;
+    clearAll: boolean;
+}
+export type ValidPasswordStatus = "effective" | "toBeEffective" | "frozen" | "freezing" | "synchronizing" | "toBeDeleted";
+export type InvalidPasswordStatus = "expired";
+export type InvalidReason = "synchronizationFailed" | "passwordFull" | "deleted";
+export interface PasswrodBaseInfo {
+    unlockBindingId: string;
+    effectiveConfig: EffectiveConfig;
+    name: string;
+    type: TemporaryPasswordType;
+    sn: number;
+    hasClearPwd: boolean;
+    clearInfo?: {
+        name: string;
+        effectiveConfig: EffectiveConfig;
+    };
+}
+export interface EffectivePasswrodItem extends PasswrodBaseInfo {
+    status: ValidPasswordStatus;
+}
+export interface InvalidPasswordItem extends PasswrodBaseInfo {
+    status: "expired";
+    invalidReason: InvalidReason;
+}
+export interface GetInvalidListParams {
+    page?: number;
+    pageSize?: number;
+}
+export interface FreezeParams {
+    unlockBindingId: string;
+}
+export interface RenameParams {
+    unlockBindingId: string;
+    name: string;
+}
+export interface CreateOnlineUnlimitedParams {
+    password: string;
+    name: string;
+    effective: EffectiveConfig;
+    phone?: string;
+    countryCode?: string;
+}
+export interface CreateOfflineParams {
+    name: string;
+    effective: EffectiveConfig;
+    isOnce: boolean;
+}
+export type OfflineTempType = "once" | "multiple";
+export interface OfflineTempResult {
+    type: OfflineTempType;
+    name: string;
+    password: string;
+    unlockBindingId: string;
+    pwdId: string;
+    effectiveConfig: EffectiveConfig;
+}
+export interface OnlinePasswordItem {
+    effective: number;
+    unlockBindingId: string;
+    effectiveTime: number;
+    invalidTime: number;
+    name: string;
+    phase: number;
+    scheduleDetails: EffectiveConfig;
+    status: "effective" | "synchronizing" | "expired" | "disabled" | "invalid";
+}
+export interface OfflinePasswordItem {
+    email: string;
+    gmtExpired: number;
+    gmtStart: number;
+    hasClearPwd: boolean;
+    mobile: string;
+    pwd: string;
+    pwdId: string;
+    pwdName: string;
+    pwdTypeCode: "once" | "multiple" | "clear_one" | "clear_all";
+    revokedPwdName: string;
+    status: number;
+    timeZoneId: string;
+}
+export type OfflinePasswordType = "once" | "multiple" | "clear_one" | "clear_all";

package/lib/feature/password/temporary/types.js

@@ -0,0 +1 @@
+export {};