akanjs 2.2.4 → 2.2.6

package/types/client/capacitor.d.ts

@@ -0,0 +1,233 @@
+export type CapacitorDeviceInfo = {
+    platform: string;
+    isVirtual: boolean;
+    osVersion: string;
+    [key: string]: unknown;
+};
+export type CapacitorKeyboardInfo = {
+    keyboardHeight: number;
+};
+export type CapacitorPermissionState = "prompt" | "prompt-with-rationale" | "granted" | "denied" | string;
+export type CapacitorAppModule = {
+    App: {
+        addListener: (eventName: string, listenerFunc: (...args: unknown[]) => void) => Promise<unknown> | unknown;
+        removeAllListeners: () => Promise<void> | void;
+        getInfo: () => Promise<{
+            id: string;
+            version: string;
+            build: string;
+            [key: string]: unknown;
+        }>;
+    };
+};
+export type CapacitorBrowserModule = {
+    Browser: {
+        open: (options: {
+            url: string;
+            presentationStyle?: string;
+        }) => Promise<void> | void;
+    };
+};
+export type CapacitorCameraModule = {
+    Camera: {
+        checkPermissions: () => Promise<{
+            camera: CapacitorPermissionState;
+            photos: CapacitorPermissionState;
+        }>;
+        requestPermissions: () => Promise<{
+            camera: CapacitorPermissionState;
+            photos: CapacitorPermissionState;
+        }>;
+        getPhoto: (options: Record<string, unknown>) => Promise<{
+            dataUrl?: string;
+            [key: string]: unknown;
+        }>;
+        pickImages: (options: Record<string, unknown>) => Promise<{
+            photos: unknown[];
+            [key: string]: unknown;
+        }>;
+    };
+    CameraResultType: {
+        DataUrl: string;
+    };
+    CameraSource: {
+        Prompt: string;
+        Camera: string;
+        Photos: string;
+    };
+};
+export type CapacitorContactsModule = {
+    Contacts: {
+        checkPermissions: () => Promise<{
+            contacts: CapacitorPermissionState;
+        }>;
+        requestPermissions: () => Promise<{
+            contacts: CapacitorPermissionState;
+        }>;
+        getContacts: (options: Record<string, unknown>) => Promise<{
+            contacts: unknown[];
+        }>;
+    };
+};
+export type CapacitorCoreModule = {
+    CapacitorCookies: {
+        setCookie: (options: {
+            key: string;
+            value: string;
+            path?: string;
+        }) => Promise<void> | void;
+    };
+};
+export type CapacitorDeviceModule = {
+    Device: {
+        getInfo: () => Promise<CapacitorDeviceInfo>;
+        getLanguageCode: () => Promise<{
+            value: string;
+        }>;
+    };
+};
+export type CapacitorFcmModule = {
+    FCM: {
+        setAutoInit: (options: {
+            enabled: boolean;
+        }) => Promise<void> | void;
+        getToken: () => Promise<{
+            token: string;
+        }>;
+    };
+};
+export type CapacitorGeolocationModule = {
+    Geolocation: {
+        requestPermissions: () => Promise<{
+            location: string;
+            coarseLocation: string;
+            [key: string]: string;
+        }>;
+        getCurrentPosition: () => Promise<unknown>;
+    };
+};
+export type CapacitorHapticsModule = {
+    ImpactStyle: {
+        Light: string;
+        Medium: string;
+        Heavy: string;
+    };
+    Haptics: {
+        vibrate: (options: {
+            duration: number;
+        }) => Promise<void> | void;
+        impact: (options: {
+            style: string;
+        }) => Promise<void> | void;
+        selectionStart: () => Promise<void> | void;
+        selectionChanged: () => Promise<void> | void;
+        selectionEnd: () => Promise<void> | void;
+    };
+};
+export type CapacitorKeyboardModule = {
+    Keyboard: {
+        show: () => Promise<void> | void;
+        hide: () => Promise<void> | void;
+        addListener: (eventName: string, listenerFunc: (info: CapacitorKeyboardInfo) => void) => Promise<unknown> | unknown;
+        removeAllListeners: () => Promise<void> | void;
+    };
+};
+export type CapacitorPreferencesModule = {
+    Preferences: {
+        get: (options: {
+            key: string;
+        }) => Promise<{
+            value: string | null;
+        }>;
+        set: (options: {
+            key: string;
+            value: string;
+        }) => Promise<void> | void;
+        remove: (options: {
+            key: string;
+        }) => Promise<void> | void;
+    };
+};
+export type CapacitorPushNotificationsModule = {
+    PushNotifications: {
+        requestPermissions: () => Promise<{
+            receive: "granted" | "denied" | string;
+        }>;
+        checkPermissions: () => Promise<{
+            receive: "granted" | "denied" | string;
+        }>;
+        register: () => Promise<void> | void;
+    };
+};
+export type CapacitorSafeAreaModule = {
+    SafeArea: {
+        getSafeAreaInsets: () => Promise<{
+            insets: {
+                top: number;
+                bottom: number;
+            };
+        }>;
+    };
+};
+export type CapacitorUpdaterModule = {
+    CapacitorUpdater: {
+        notifyAppReady: () => Promise<void> | void;
+        getPluginVersion: () => Promise<{
+            version: string;
+        }>;
+        getDeviceId: () => Promise<{
+            deviceId: string;
+        }>;
+        current: () => Promise<{
+            bundle: {
+                version: string;
+            };
+            native: string;
+        }>;
+        getBuiltinVersion: () => Promise<{
+            version: string;
+        }>;
+        download: (options: {
+            url: string;
+            version: string;
+        }) => Promise<unknown>;
+        set: (bundle: unknown) => Promise<void> | void;
+    };
+};
+type CapacitorModuleMap = {
+    app: CapacitorAppModule;
+    browser: CapacitorBrowserModule;
+    camera: CapacitorCameraModule;
+    contacts: CapacitorContactsModule;
+    core: CapacitorCoreModule;
+    device: CapacitorDeviceModule;
+    fcm: CapacitorFcmModule;
+    geolocation: CapacitorGeolocationModule;
+    haptics: CapacitorHapticsModule;
+    keyboard: CapacitorKeyboardModule;
+    preferences: CapacitorPreferencesModule;
+    pushNotifications: CapacitorPushNotificationsModule;
+    safeArea: CapacitorSafeAreaModule;
+    updater: CapacitorUpdaterModule;
+};
+type CapacitorImportCache = Partial<{
+    [K in keyof CapacitorModuleMap]: Promise<CapacitorModuleMap[keyof CapacitorModuleMap]>;
+}>;
+declare global {
+    var __AKAN_CAPACITOR_IMPORTS__: CapacitorImportCache | undefined;
+}
+export declare const loadCapacitorApp: () => Promise<CapacitorAppModule>;
+export declare const loadCapacitorBrowser: () => Promise<CapacitorBrowserModule>;
+export declare const loadCapacitorCamera: () => Promise<CapacitorCameraModule>;
+export declare const loadCapacitorContacts: () => Promise<CapacitorContactsModule>;
+export declare const loadCapacitorCore: () => Promise<CapacitorCoreModule>;
+export declare const loadCapacitorDevice: () => Promise<CapacitorDeviceModule>;
+export declare const loadCapacitorFcm: () => Promise<CapacitorFcmModule>;
+export declare const loadCapacitorGeolocation: () => Promise<CapacitorGeolocationModule>;
+export declare const loadCapacitorHaptics: () => Promise<CapacitorHapticsModule>;
+export declare const loadCapacitorKeyboard: () => Promise<CapacitorKeyboardModule>;
+export declare const loadCapacitorPreferences: () => Promise<CapacitorPreferencesModule>;
+export declare const loadCapacitorPushNotifications: () => Promise<CapacitorPushNotificationsModule>;
+export declare const loadCapacitorSafeArea: () => Promise<CapacitorSafeAreaModule>;
+export declare const loadCapacitorUpdater: () => Promise<CapacitorUpdaterModule>;
+export {};

package/types/client/clientRuntime.d.ts

@@ -0,0 +1,63 @@
+import type { SliceMeta } from "akanjs/fetch";
+import type { ReactNode } from "react";
+import type { TransMessageOption } from "./makePageProto.d.ts";
+type RuntimeTranslate = ((key: string, param?: Record<string, string | number>) => string) & {
+    _: (key: string, param?: Record<string, string | number>) => string;
+    rich: (key: string, param?: Record<string, string | number>) => ReactNode;
+    trans: <Returns extends ReactNode>(translation: Record<"en" | "ko" | (string & {}), Returns>) => Returns extends string ? string : Returns;
+};
+type RuntimePage = {
+    path: string;
+    l: RuntimeTranslate;
+    lang: string;
+};
+type RuntimeMsg = {
+    info: (key: string, option?: TransMessageOption) => void;
+    success: (key: string, option?: TransMessageOption) => void;
+    error: (key: string, option?: TransMessageOption) => void;
+    warning: (key: string, option?: TransMessageOption) => void;
+    loading: (key: string, option?: TransMessageOption) => void;
+};
+type RuntimeErr = {
+    new (key: string, data?: Record<string, unknown>, option?: Record<string, unknown>): Error;
+    BadRequest?: RuntimeErr;
+    Conflict?: RuntimeErr;
+    Forbidden?: RuntimeErr;
+    NotFound?: RuntimeErr;
+    Unauthorized?: RuntimeErr;
+    fromJSON?: (payload: Record<string, unknown>) => Error;
+    [key: string]: unknown;
+};
+type RuntimeWs = {
+    connected: boolean;
+    on: (event: string, handler: (...args: unknown[]) => void) => void;
+    off: (event: string, handler: (...args: unknown[]) => void) => void;
+};
+type RuntimeFetch = typeof globalThis.fetch & {
+    instance: unknown;
+    origin: string;
+    serializedSignal: Record<string, unknown>;
+    setJwt: (jwt: string | null) => void;
+    slice: Record<string, SliceMeta>;
+    ws: RuntimeWs;
+    [key: string]: unknown;
+};
+export interface ClientRuntime {
+    msg: RuntimeMsg;
+    Err: RuntimeErr;
+    usePage: () => RuntimePage;
+    fetch: RuntimeFetch;
+    sig: Record<PropertyKey, unknown>;
+}
+type RuntimeScope = "app" | "lib";
+export declare const registerClientRuntime: <Runtime>(runtime: Runtime, { scope }?: {
+    scope?: RuntimeScope;
+}) => Runtime;
+export declare const getClientRuntime: () => ClientRuntime;
+export declare const isClientRuntimeRegistered: () => boolean;
+export declare const msg: RuntimeMsg;
+export declare const Err: RuntimeErr;
+export declare const usePage: ClientRuntime["usePage"];
+export declare const fetch: RuntimeFetch;
+export declare const sig: Record<PropertyKey, unknown>;
+export {};

package/types/client/cookie.d.ts

@@ -0,0 +1,33 @@
+import type { Account } from "akanjs/fetch";
+interface CookieOptions {
+    path?: string;
+    sameSite?: "strict" | "lax" | "none";
+    secure?: boolean;
+}
+export declare const cookies: () => Map<string, {
+    name: string;
+    value: string;
+}>;
+export declare const setCookie: (key: string, value: string, options?: CookieOptions) => void;
+export declare const getCookie: (key: string) => string | undefined;
+export declare const removeCookie: (key: string, options?: {
+    path: string;
+}) => boolean | undefined;
+export declare const headers: () => Map<string, string>;
+export declare const getHeader: (key: string) => string | undefined;
+/** Decodes the current JWT into account data when it belongs to this app/environment. */
+export declare const getAccount: <AddData = unknown>() => Account<AddData>;
+export interface GetOption {
+    unauthorize: string;
+}
+interface SetAuthOption {
+    jwt: string;
+}
+/** Sets the active auth token on fetch, cookie storage, and client storage. */
+export declare const setAuth: ({ jwt }: SetAuthOption) => void;
+interface InitAuthOption {
+    jwt?: string;
+}
+export declare const initAuth: ({ jwt }?: InitAuthOption) => void;
+export declare const resetAuth: () => void;
+export {};

package/types/client/createFont.d.ts

@@ -0,0 +1,6 @@
+export declare const createFont: (_data: unknown) => null;
+export default createFont;
+export declare const Nanum_Gothic_Coding: (_data: unknown) => null;
+export declare const Noto_Sans_KR: (_data: unknown) => null;
+export declare const Inter: (_data: unknown) => null;
+export declare const Roboto: (_data: unknown) => null;

package/types/client/csrTypes.d.ts

@@ -0,0 +1,262 @@
+import type { ReactDOMAttributes } from "@use-gesture/react/dist/declarations/src/types";
+import type { PromiseOrObject } from "akanjs/base";
+import { type ForwardRefExoticComponent, type ReactNode, type RefObject } from "react";
+import type { AnimatedComponent, AnimatedProps, Interpolation, SpringValue } from "react-spring";
+import type { RouterInstance } from "./router.d.ts";
+import type { ReactFont } from "./types.d.ts";
+export type TransitionType = "none" | "fade" | "bottomUp" | "stack" | "scaleOut";
+/** Per-page CSR configuration for transition, safe-area, gesture, and cache behavior. */
+export interface PageConfig {
+    transition?: TransitionType;
+    safeArea?: boolean | "top" | "bottom";
+    topInset?: boolean | number;
+    /**
+     * @default 48px
+     */
+    bottomInset?: boolean | number;
+    gesture?: boolean;
+    cache?: boolean;
+    rscCache?: "public" | false;
+    rscCacheTtl?: number;
+    topSafeAreaColor?: string;
+    bottomSafeAreaColor?: string;
+}
+export interface CsrState {
+    transition: TransitionType;
+    topSafeArea: number;
+    bottomSafeArea: number;
+    topInset: number;
+    bottomInset: number;
+    gesture: boolean;
+    cache: boolean;
+    topSafeAreaColor?: string;
+    bottomSafeAreaColor?: string;
+}
+export declare const DEFAULT_TOP_INSET = 48;
+export declare const DEFAULT_BOTTOM_INSET = 60;
+export interface PageProps {
+    params: {
+        [key: string]: string;
+    };
+    searchParams: {
+        [key: string]: string | string[];
+    };
+}
+/** Props passed to Akan layout route modules. */
+export interface LayoutProps extends PageProps {
+    children: ReactNode;
+}
+export interface PageLoadingProps {
+    params: {
+        [key: string]: string;
+    };
+}
+export interface LayoutLoadingProps extends PageLoadingProps {
+    children: ReactNode;
+}
+export interface LayoutNotFoundProps extends PageProps {
+    pathname: string;
+}
+export interface LayoutErrorProps extends LayoutNotFoundProps {
+    error?: unknown;
+    digest?: string;
+}
+export type Head = ReactNode;
+export type GenerateHead = (props: PageProps) => PromiseOrObject<Head | null | undefined>;
+export type ResolveHead = (props: PageProps) => PromiseOrObject<Head | null | undefined>;
+export type HeadProps = PageProps;
+export type PageRender = (props: PageProps) => PromiseOrObject<ReactNode>;
+export type LayoutRender = (props: LayoutProps) => PromiseOrObject<ReactNode>;
+export type PageLoadingRender = (props: PageLoadingProps) => PromiseOrObject<ReactNode>;
+export type LayoutLoadingRender = (props: LayoutLoadingProps) => PromiseOrObject<ReactNode>;
+export type LayoutNotFoundRender = (props: LayoutNotFoundProps) => PromiseOrObject<ReactNode>;
+export type LayoutErrorRender = (props: LayoutErrorProps) => PromiseOrObject<ReactNode>;
+export interface RouteRender {
+    render: LayoutRender | PageRender;
+    isAsync?: boolean;
+    Loading?: LayoutLoadingRender | PageLoadingRender;
+    NotFound?: LayoutNotFoundRender;
+    Error?: LayoutErrorRender;
+    resolveNotFound?: () => PromiseOrObject<LayoutNotFoundRender | undefined>;
+    resolveError?: () => PromiseOrObject<LayoutErrorRender | undefined>;
+    resolveHead?: ResolveHead;
+    getPageConfig?: () => PromiseOrObject<PageConfig | undefined>;
+}
+export interface WebAppManifestIcon {
+    src: string;
+    sizes?: string;
+    type?: string;
+    purpose?: string;
+    [key: string]: unknown;
+}
+export interface WebAppManifest {
+    name?: string;
+    shortName?: string;
+    startUrl?: string;
+    scope?: string;
+    display?: "fullscreen" | "standalone" | "minimal-ui" | "browser" | (string & {});
+    displayOverride?: string[];
+    orientation?: string;
+    themeColor?: string;
+    backgroundColor?: string;
+    description?: string;
+    lang?: string;
+    dir?: "ltr" | "rtl" | "auto";
+    icons?: WebAppManifestIcon[];
+    categories?: string[];
+    screenshots?: WebAppManifestIcon[];
+    [key: string]: unknown;
+}
+export interface PageModule {
+    default?: PageRender;
+    pageConfig?: PageConfig;
+    head?: Head;
+    generateHead?: GenerateHead;
+    Loading?: PageLoadingRender;
+}
+export interface LayoutModule {
+    default?: LayoutRender;
+    head?: Head;
+    generateHead?: GenerateHead;
+    fonts?: ReactFont[];
+    manifest?: WebAppManifest;
+    theme?: string;
+    reconnect?: boolean;
+    layoutStyle?: "mobile" | "web";
+    gaTrackingId?: string;
+    Loading?: LayoutLoadingRender;
+    NotFound?: LayoutNotFoundRender;
+    Error?: LayoutErrorRender;
+}
+export type RouteModule = PageModule | LayoutModule;
+export interface Route {
+    PageConfig?: PageConfig;
+    path: string;
+    renderPage?: RouteRender;
+    renderLayout?: RouteRender;
+    pageIncludesOwnLayout?: boolean;
+    isSpecialRoute?: boolean;
+    loader?: () => any;
+    pageState?: PageState;
+    children: Map<string, Route>;
+}
+export type AnimatedDivProps = AnimatedComponent<"div"> extends ForwardRefExoticComponent<AnimatedProps<infer P>> ? P : never;
+export type TransitionStyle = AnimatedDivProps["style"];
+export interface SafeAreaTransition {
+    containerStyle: TransitionStyle;
+}
+export interface ContainerTransition {
+    containerStyle: TransitionStyle;
+    contentStyle: TransitionStyle;
+    prevContentStyle: TransitionStyle;
+}
+export interface PageTransition {
+    containerStyle: TransitionStyle;
+    contentStyle: TransitionStyle;
+}
+export interface CsrTransitionStyles {
+    topSafeArea: SafeAreaTransition | null;
+    page: PageTransition | null;
+    prevPage: PageTransition | null;
+    topInset: ContainerTransition | null;
+    bottomInset: ContainerTransition | null;
+    topLeftAction: ContainerTransition | null;
+    bottomSafeArea: SafeAreaTransition | null;
+}
+export type PageState = CsrState & {
+    topInset: number;
+    bottomInset: number;
+};
+export declare const defaultPageState: PageState;
+export interface Location {
+    href: string;
+    pathname: string;
+    search: string;
+    params: {
+        [key: string]: string;
+    };
+    searchParams: {
+        [key: string]: string | string[];
+    };
+    pathRoute: PathRoute;
+    hash: string;
+}
+export interface LocationState {
+    location: Location;
+    prevLocation: Location | null;
+}
+export interface History {
+    type: "initial" | "forward" | "back";
+    locations: Location[];
+    scrollMap: Map<string, number>;
+    idxMap: Map<string, number>;
+    cachedLocationMap: Map<string, Location>;
+    idx: number;
+}
+export interface RouterProps {
+    push: (path: string) => void;
+    replace: (path: string) => void;
+    refresh: () => void;
+    back: () => void | Promise<void>;
+}
+export interface RouteState {
+    clientWidth: number;
+    clientHeight: number;
+    location: Location;
+    prevLocation: Location | null;
+    history: RefObject<History>;
+    topSafeAreaRef: RefObject<HTMLDivElement | null>;
+    bottomSafeAreaRef: RefObject<HTMLDivElement | null>;
+    prevPageContentRef: RefObject<HTMLDivElement | null>;
+    pageContentRef: RefObject<HTMLDivElement | null>;
+    frameRootRef: RefObject<HTMLDivElement | null>;
+    onBack: RefObject<{
+        [K in TransitionType]?: () => Promise<void>;
+    }>;
+    router: RouterInstance;
+    pathRoutes: PathRoute[];
+}
+export type UseCsrTransition = CsrTransitionStyles & {
+    pageBind: (...args: any[]) => ReactDOMAttributes;
+    pageClassName: string;
+    transDirection: "vertical" | "horizontal" | "none";
+    transUnitRange: number[];
+    transUnit: SpringValue<number>;
+    transPercent: Interpolation<number>;
+    transProgress: Interpolation<number>;
+};
+export type CsrContextType = RouteState & UseCsrTransition;
+export declare const csrContext: import("react").Context<CsrContextType>;
+export declare const useCsr: () => CsrContextType;
+export interface PathContextType {
+    pageType: "current" | "prev" | "cached";
+    location: Location;
+    prefix?: string;
+    gestureEnabled: boolean;
+    setGestureEnabled: (enabled: boolean) => void;
+}
+export declare const pathContext: import("react").Context<PathContextType>;
+export declare const usePathCtx: () => PathContextType;
+export interface PathRoute {
+    path: string;
+    pathSegments: string[];
+    renderPage: RouteRender;
+    pageState: PageState;
+    renderRootLayouts: RouteRender[];
+    renderLayouts: RouteRender[];
+    resolveHead?: ResolveHead;
+    isSpecialRoute?: boolean;
+}
+export interface LayoutFallbackRoute {
+    path: string;
+    pathSegments: string[];
+    renderRootLayouts: RouteRender[];
+    renderLayouts: RouteRender[];
+}
+export interface RouteGuide {
+    pathSegment: string;
+    pathRoute?: PathRoute;
+    children: {
+        [key: string]: RouteGuide;
+    };
+}

package/types/client/decorators.d.ts

@@ -0,0 +1,7 @@
+interface ToastProps {
+    root?: string;
+    duration?: number;
+}
+/** Decorates async actions with loading/success/error toast messages from `msg`. */
+export declare const Toast: ({ root, duration }?: ToastProps) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export {};

package/types/client/device.d.ts

@@ -0,0 +1,41 @@
+import type { RefObject } from "react";
+import type { CapacitorDeviceInfo, CapacitorHapticsModule, CapacitorKeyboardModule } from "./capacitor.d.ts";
+type DeviceInfo = CapacitorDeviceInfo;
+type Keyboard = CapacitorKeyboardModule["Keyboard"];
+type Haptics = CapacitorHapticsModule["Haptics"];
+type ImpactStyle = CapacitorHapticsModule["ImpactStyle"];
+interface DeviceInitOption {
+    lang: string;
+    info: DeviceInfo;
+    topSafeArea: number;
+    bottomSafeArea: number;
+    keyboard: Keyboard;
+    haptics: Haptics;
+    impactStyle: ImpactStyle;
+}
+export declare const isMobileDevice: () => boolean;
+/** Capacitor-aware device helper for platform info, safe areas, keyboard, haptics, and scroll state. */
+export declare class Device {
+    #private;
+    static instance: Device | null;
+    static load({ lang, supportLanguages, }: {
+        lang?: string;
+        supportLanguages?: string[] | readonly string[];
+    }): Promise<Device>;
+    static getDevice(): Device;
+    info: DeviceInfo;
+    lang: string;
+    topSafeArea: number;
+    bottomSafeArea: number;
+    isMobile: boolean;
+    constructor({ lang, info, topSafeArea, bottomSafeArea, keyboard, haptics, impactStyle }: DeviceInitOption);
+    setPageContentRef(pageContentRef: RefObject<HTMLDivElement | null>): void;
+    showKeyboard(): Promise<void>;
+    hideKeyboard(): Promise<void>;
+    listenKeyboardChanged(onKeyboardChanged: (height: number) => void): void;
+    unlistenKeyboardChanged(): void;
+    vibrate(type?: "light" | "medium" | "heavy" | number): Promise<void>;
+    getScrollTop(): number;
+    setScrollTop(scrollTop: number): void;
+}
+export {};

package/types/client/fetch.d.ts

@@ -0,0 +1 @@
+export { fetch, sig } from "./clientRuntime.d.ts";

package/types/client/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./clientRuntime.d.ts";
+export * from "./cookie.d.ts";
+export * from "./createFont.d.ts";
+export * from "./csrTypes.d.ts";
+export * from "./decorators.d.ts";
+export * from "./device.d.ts";
+export * from "./locale.d.ts";
+export * from "./makePageProto.d.ts";
+export * from "./router.d.ts";
+export * from "./rscNavigation.d.ts";
+export * from "./storage.d.ts";
+export * from "./translator.d.ts";
+export * from "./types.d.ts";
+export * from "./useClient.d.ts";

package/types/client/locale.d.ts

@@ -0,0 +1,5 @@
+export declare const dictionaryContext: import("react").Context<{
+    [key: string]: {
+        [key: string]: string;
+    };
+}>;