akanjs 2.2.4 → 2.2.5

package/types/client/router.d.ts

@@ -0,0 +1,66 @@
+export interface RouteOptions {
+    scrollToTop?: boolean;
+}
+export interface RouterInstance {
+    push: (href: string, routeOptions?: RouteOptions) => void;
+    replace: (href: string, routeOptions?: RouteOptions) => void;
+    back: (routeOptions?: RouteOptions) => void;
+    refresh: () => void;
+}
+interface RouterOptions {
+    prefix?: string;
+    lang?: string;
+}
+interface SsrServerRouterOption extends RouterOptions {
+    type: "ssr";
+    side: "server";
+}
+interface SsrClientRouterOption extends RouterOptions {
+    type: "ssr";
+    side: "client";
+    router: RouterInstance;
+}
+interface CSRClientRouterOption extends RouterOptions {
+    type: "csr";
+    router: RouterInstance;
+}
+export type RedirectMethod = "replace" | "push";
+export declare class AkanRedirectError extends Error {
+    readonly location: string;
+    readonly method: RedirectMethod;
+    readonly digest = "AKAN_REDIRECT";
+    constructor(location: string, method?: RedirectMethod);
+}
+export declare class AkanNotFoundError extends Error {
+    readonly digest = "AKAN_NOT_FOUND";
+    constructor();
+}
+declare global {
+    var __AKAN_ROUTER__: Router | undefined;
+}
+export declare const getPathInfo: (requestUrl: string, lang: string, prefix: string) => {
+    path: string;
+    pathname: string;
+    hash: string;
+    search: string;
+    href: string;
+};
+declare class Router {
+    #private;
+    isInitialized: boolean;
+    init(options: SsrClientRouterOption | SsrServerRouterOption | CSRClientRouterOption): void;
+    push(href: string, routeOptions?: RouteOptions): never;
+    replace(href: string, routeOptions?: RouteOptions): never;
+    back(routeOptions?: RouteOptions): never;
+    refresh(): never;
+    redirect(href: string): never;
+    notFound(): never;
+    setLang(lang: string): never;
+    getPath(pathname?: string): string;
+    getFullPath(withLang?: boolean): string;
+    getPrefix(): string;
+    getPrefixedPath(path: string): string;
+}
+/** Akan navigation singleton that normalizes language/base-path prefixes before routing. */
+export declare const router: Router;
+export {};

package/types/client/rscNavigation.d.ts

@@ -0,0 +1,19 @@
+declare global {
+    var __AKAN_RSC_CLEAR_CACHE__: (() => void) | undefined;
+    var __AKAN_RSC_NAVIGATE__: ((href: string, options?: {
+        replace?: boolean;
+        scrollToTop?: boolean;
+    }) => Promise<void>) | undefined;
+}
+export declare const clearRscNavigationCache: () => void;
+export declare const navigateRsc: (href: string, options?: {
+    replace?: boolean;
+    scrollToTop?: boolean;
+}) => Promise<void> | undefined;
+export declare const useRscNavigation: () => {
+    clearCache: () => void;
+    navigate: (href: string, options?: {
+        replace?: boolean;
+        scrollToTop?: boolean;
+    }) => Promise<void> | undefined;
+};

package/types/client/storage.d.ts

@@ -0,0 +1,5 @@
+export declare const storage: {
+    getItem: (key: string) => Promise<string | null | undefined>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+};

package/types/client/translator.d.ts

@@ -0,0 +1,18 @@
+export interface Dictionary {
+    [key: string]: {
+        [key: string]: unknown;
+    };
+}
+export interface AllDictionary {
+    [key: string]: Dictionary;
+}
+export declare class Translator {
+    #private;
+    static setActiveLocale(lang: string | undefined): void;
+    static getActiveLocale(): string | undefined;
+    constructor(dictionary: Record<string, Record<string, Record<string, unknown>>>);
+    hasDictionary(lang: string): boolean;
+    static seed(lang: string, dict: Dictionary | undefined): void;
+    translate(lang: string, key: string, param?: Record<string, string | number>): string;
+    getDictionary(lang: string): Promise<Dictionary>;
+}

package/types/client/types.d.ts

@@ -0,0 +1,145 @@
+import type { BaseInsight } from "akanjs/constant";
+import type { FetchInitForm, SliceMeta } from "akanjs/fetch";
+import { type ClassValue } from "clsx";
+import type { ReactElement, ReactNode } from "react";
+/** Composes class names with the shared clsx implementation. */
+export declare const clsx: (...args: ClassValue[]) => string;
+export type ReactFontStyle = "normal" | "italic" | "oblique";
+export type ReactFontDisplay = "auto" | "block" | "swap" | "fallback" | "optional";
+export type ReactFontCategory = "monospace" | "sans-serif" | "serif" | "display";
+export type ReactFontSubset = "latin" | "latin-ext" | "ks-x-1001" | "auto" | (string & {});
+export interface ReactFontDeclaration {
+    prop: string;
+    value: string;
+}
+export interface ReactFontPath {
+    src: string;
+    weight: number | string;
+    style?: ReactFontStyle;
+    declarations?: ReactFontDeclaration[];
+}
+export interface ReactFontFace {
+    font: ReactFont;
+    path: ReactFontPath;
+    src: string;
+    weight: number | string;
+    style: ReactFontStyle;
+    optimizedSrc: string;
+}
+export declare const loadFonts: <T extends ReactFont[]>(fonts: T) => T;
+export declare const getFontVariableName: (font: ReactFont) => string;
+export declare const getFontFallbackName: (font: ReactFont) => string;
+export declare const isFontOptimizationEnabled: (font: ReactFont) => boolean;
+export declare const isFontPreloadEnabled: (font: ReactFont) => boolean;
+export declare const getFontStyles: (font: ReactFont) => ReactFontStyle[];
+export declare const getFontFaces: (font: ReactFont) => ReactFontFace[];
+export declare const getOptimizedFontSrc: (font: ReactFont, path: ReactFontPath) => string;
+/** Common props for list/zone components that render many model records. */
+export interface ModelsProps<M extends {
+    id: string;
+}> {
+    className?: string;
+    slice?: SliceMeta;
+    query?: Record<string, unknown>;
+    init?: FetchInitForm<any, any>;
+    onClickItem?: (model: M) => unknown;
+}
+/** Common props for unit/view components that render one named model record. */
+export type ModelProps<T extends string, L extends {
+    id: string;
+}> = {
+    [key in T]: L;
+} & {
+    className?: string;
+    slice?: SliceMeta;
+    onClick?: (model: L) => unknown;
+    actions?: DataAction[];
+    columns?: DataColumn<L>[];
+    href?: string;
+};
+export interface ModelDashboardProps<Summary> {
+    className?: string;
+    summary: Summary;
+    queryMap?: Record<string, unknown>;
+    columns?: (keyof Summary)[];
+    hidePresents?: boolean;
+    slice?: SliceMeta;
+}
+export interface ModelInsightProps<Insight = BaseInsight> {
+    className?: string;
+    insight: Insight;
+    slice?: SliceMeta;
+}
+export interface ModelEditProps {
+    slice?: SliceMeta;
+}
+export interface ModelViewProps {
+    id?: string;
+    slice?: SliceMeta;
+}
+export type DataAction = "edit" | "view" | "remove" | null | undefined | ReactElement;
+export interface DataTool {
+    key: string;
+    render: () => ReactNode;
+}
+export type DataColumn<L> = string | {
+    key: keyof L;
+    title?: string;
+    value?: (value: any, model: L) => string | number | boolean | undefined | null | object;
+    responsive?: boolean;
+    render?: (value: any, model: L) => ReactNode;
+    only?: "user" | "admin";
+};
+export interface DataMenuItem {
+    key: string;
+    icon: ReactNode;
+    label?: string;
+    render: () => ReactNode;
+}
+export interface DataMenu {
+    [key: string]: DataMenuItem;
+}
+export interface UserMenuItem {
+    title: string | ReactNode;
+    icon?: ReactNode;
+    path: string;
+    query?: Record<string, unknown>;
+    children?: UserMenuItem[];
+    onClick?: () => void;
+}
+export interface MenuItem {
+    icon?: ReactNode;
+    title: string | ReactNode;
+    href: string;
+    hide?: "mobile" | "pc";
+    children?: MenuItem[];
+    onClick?: () => void;
+}
+export interface ReactFont {
+    name: string;
+    default?: boolean;
+    paths: ReactFontPath[];
+    styles?: ReactFontStyle[];
+    display?: ReactFontDisplay;
+    preload?: boolean;
+    fallbacks?: string[];
+    fallbackName?: string;
+    subsets?: ReactFontSubset[];
+    subsetText?: string;
+    subsetFiles?: string[];
+    subset?: false;
+    category?: ReactFontCategory;
+    variable?: string;
+    className?: string;
+    declarations?: ReactFontDeclaration[];
+    adjustFontFallback?: boolean;
+    optimize?: boolean;
+}
+/** Font declaration consumed by Akan layout modules and font optimization. */
+export type Font = ReactFont;
+export interface RootLayoutProps {
+    children: ReactNode;
+    params: {
+        lang: "en" | "ko" | (string & {});
+    };
+}

package/types/client/useClient.d.ts

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

package/types/client.d.ts

@@ -0,0 +1 @@
+export * from "./client/index.d.ts";

package/types/common/Logger.d.ts

@@ -0,0 +1,41 @@
+declare const logLevels: readonly ["trace", "verbose", "debug", "log", "info", "warn", "error"];
+export type LogLevel = (typeof logLevels)[number];
+export interface LoggerSinkEntry {
+    stream: "stdout" | "stderr";
+    level?: LogLevel;
+    message: string;
+    plainMessage: string;
+}
+export type LoggerSink = (entry: LoggerSinkEntry) => void | Promise<void>;
+/** Log-level aware logger used by Akan runtime, CLI, and application services. */
+export declare class Logger {
+    #private;
+    static level: LogLevel;
+    static fileLevel: LogLevel;
+    static setLevel(level: LogLevel): void;
+    static addSink(sink: LoggerSink): () => void;
+    static removeSink(sink: LoggerSink): void;
+    static setFileLevel(level: LogLevel): void;
+    static isVerbose(): boolean;
+    name?: string;
+    constructor(name?: string);
+    trace(msg: string, context?: string, name?: string): void;
+    verbose(msg: string, context?: string, name?: string): void;
+    debug(msg: string, context?: string, name?: string): void;
+    log(msg: string, context?: string, name?: string): void;
+    info(msg: string, context?: string, name?: string): void;
+    warn(msg: string, context?: string, name?: string): void;
+    error(msg: string, context?: string, name?: string): void;
+    raw(msg: string, method?: "console" | "process"): void;
+    rawLog(msg: string, method?: "console" | "process"): void;
+    static trace(msg: string, context?: string, name?: string): void;
+    static verbose(msg: string, context?: string, name?: string): void;
+    static debug(msg: string, context?: string, name?: string): void;
+    static log(msg: string, context?: string, name?: string): void;
+    static info(msg: string, context?: string, name?: string): void;
+    static warn(msg: string, context?: string, name?: string): void;
+    static error(msg: string, context?: string, name?: string): void;
+    static rawLog(msg?: string, method?: "console" | "process", outputStream?: "log" | "error"): void;
+    static raw(msg?: string, method?: "console" | "process", outputStream?: "log" | "error"): void;
+}
+export {};

package/types/common/applyMixins.d.ts

@@ -0,0 +1,3 @@
+type Cls<T = unknown> = new (...args: never[]) => T;
+export declare const applyMixins: (derivedCtor: Cls, constructors: (Cls | undefined)[], avoidKeys?: Set<string>) => Cls<unknown>;
+export {};

package/types/common/capitalize.d.ts

@@ -0,0 +1,2 @@
+/** Uppercases only the first character of a string. */
+export declare const capitalize: (str: string) => string;

package/types/common/deepObjectify.d.ts

@@ -0,0 +1,4 @@
+export declare const deepObjectify: <T = unknown>(obj: T | null | undefined, option?: {
+    serializable?: boolean;
+    convertDate?: "string" | "number";
+}) => T;

package/types/common/fileUpload.d.ts

@@ -0,0 +1,28 @@
+interface FileUploadSerializedEndpoint {
+    fileUpload?: boolean;
+}
+interface FileUploadSerializedSignal {
+    prefix?: string;
+    endpoint: Record<string, FileUploadSerializedEndpoint>;
+}
+/** Framework-owned file-upload contract shared by client-safe packages. */
+export declare const fileUploadContract: {
+    readonly fields: {
+        readonly files: "files";
+        readonly metas: "metas";
+        readonly type: "type";
+        readonly parentId: "parentId";
+    };
+    readonly buildMetas: (fileList: FileList) => {
+        lastModifiedAt: string;
+        size: number;
+    }[];
+};
+export interface FileUploadCapability {
+    refName: string;
+    endpointKey: string;
+    prefix?: string;
+}
+/** Discovers the upload endpoint marked with `{ fileUpload: true }` from the serialized signal. */
+export declare const resolveFileUploadCapability: (serializedSignal: Record<string, FileUploadSerializedSignal>) => FileUploadCapability | null;
+export {};

package/types/common/formatNumber.d.ts

@@ -0,0 +1 @@
+export declare const formatNumber: (numString: string) => string;

package/types/common/formatPhone.d.ts

@@ -0,0 +1,2 @@
+/** Formats supported phone-number strings into dashed display form. */
+export declare const formatPhone: (value: string) => string;

package/types/common/getAllPropertyDescriptors.d.ts

@@ -0,0 +1,5 @@
+type Cls<T = unknown> = new (...args: never[]) => T;
+export declare const getAllPropertyDescriptors: (objRef: Cls) => {
+    [key: string]: PropertyDescriptor;
+};
+export {};

package/types/common/hmrPhase.d.ts

@@ -0,0 +1,6 @@
+export type AkanHmrPhase = "refresh-import" | "react-refresh" | null;
+declare global {
+    var __AKAN_HMR_PHASE__: AkanHmrPhase | undefined;
+}
+export declare function getAkanHmrPhase(): AkanHmrPhase;
+export declare function isAkanHmrApplying(): boolean;

package/types/common/httpClient.d.ts

@@ -0,0 +1,20 @@
+export interface HttpClientOptions {
+    baseUrl?: string;
+    headers?: HeadersInit;
+    timeout?: number;
+}
+export interface HttpRequestOptions extends Omit<RequestInit, "body" | "headers" | "method"> {
+    headers?: HeadersInit;
+    timeout?: number;
+}
+export declare class HttpClient {
+    #private;
+    readonly baseUrl: string;
+    readonly headers: Headers;
+    readonly timeout: number | undefined;
+    constructor(options?: string | HttpClientOptions);
+    get<Returns>(url: string, options?: HttpRequestOptions): Promise<Returns>;
+    post<Returns>(url: string, data?: unknown, options?: HttpRequestOptions): Promise<Returns>;
+    put<Returns>(url: string, data?: unknown, options?: HttpRequestOptions): Promise<Returns>;
+    delete<Returns>(url: string, options?: HttpRequestOptions): Promise<Returns>;
+}

package/types/common/index.d.ts

@@ -0,0 +1,29 @@
+export { applyMixins } from "./applyMixins.d.ts";
+export { capitalize } from "./capitalize.d.ts";
+export { deepObjectify } from "./deepObjectify.d.ts";
+export { type FileUploadCapability, fileUploadContract, resolveFileUploadCapability, } from "./fileUpload.d.ts";
+export { formatNumber } from "./formatNumber.d.ts";
+export { formatPhone } from "./formatPhone.d.ts";
+export { getAllPropertyDescriptors } from "./getAllPropertyDescriptors.d.ts";
+export { type AkanHmrPhase, getAkanHmrPhase, isAkanHmrApplying } from "./hmrPhase.d.ts";
+export { HttpClient } from "./httpClient.d.ts";
+export { isDayjs } from "./isDayjs.d.ts";
+export { isEmail } from "./isEmail.d.ts";
+export { isPhoneNumber } from "./isPhoneNumber.d.ts";
+export { isQueryEqual } from "./isQueryEqual.d.ts";
+export { isValidDate } from "./isValidDate.d.ts";
+export { decodeJwtPayload } from "./jwtDecode.d.ts";
+export { Logger, type LoggerSink, type LoggerSinkEntry, type LogLevel } from "./Logger.d.ts";
+export { type AkanI18nConfig, type AkanI18nConfigInput, DEFAULT_AKAN_I18N, parseAkanI18nEnv, resolveAkanI18nConfig, } from "./localeConfig.d.ts";
+export { lowerlize } from "./lowerlize.d.ts";
+export { mergeVersion } from "./mergeVersion.d.ts";
+export { objectify } from "./objectify.d.ts";
+export { pathGet } from "./pathGet.d.ts";
+export { pathSet } from "./pathSet.d.ts";
+export { randomPick } from "./randomPick.d.ts";
+export { randomPicks } from "./randomPicks.d.ts";
+export { assertUniqueRoutePatterns, compareRouteSpecificity, isRouteSourceFile, isSpecialRouteLeaf, matchRoutePattern, normalizeRoutePattern, type ParsedRouteModuleKey, parseRouteModuleKey, type RouteModuleKind, routeSegmentToPatternPart, routeSegmentToTreePath, tryParseRouteModuleKey, type ValidatePageSourceFileOptions, type ValidateSubRoutePageKeyOptions, validatePageSourceFile, validateSubRoutePageKey, } from "./routeConvention.d.ts";
+export { sleep } from "./sleep.d.ts";
+export { splitVersion } from "./splitVersion.d.ts";
+export { getBasePathFromPathname, parseBasePaths } from "./subRoute.d.ts";
+export type * from "./types.d.ts";

package/types/common/isDayjs.d.ts

@@ -0,0 +1,2 @@
+import dayjs from "dayjs";
+export declare const isDayjs: typeof dayjs.isDayjs;

package/types/common/isEmail.d.ts

@@ -0,0 +1,2 @@
+/** Returns true when the value matches the email format accepted by Akan forms. */
+export declare const isEmail: (email?: string | null) => boolean;

package/types/common/isPhoneNumber.d.ts

@@ -0,0 +1,2 @@
+/** Returns true when the value matches Akan's supported dashed phone-number format. */
+export declare const isPhoneNumber: (phone?: string | null) => boolean;

package/types/common/isQueryEqual.d.ts

@@ -0,0 +1 @@
+export declare const isQueryEqual: (value1: unknown, value2: unknown) => boolean;

package/types/common/isValidDate.d.ts

@@ -0,0 +1,2 @@
+import { type Dayjs } from "dayjs";
+export declare const isValidDate: (d: string | Date | Dayjs) => boolean;

package/types/common/jwtDecode.d.ts

@@ -0,0 +1,2 @@
+/** Decodes a JWT payload without validating its signature. */
+export declare function decodeJwtPayload<T = unknown>(jwt: string): T;

package/types/common/localeConfig.d.ts

@@ -0,0 +1,11 @@
+export interface AkanI18nConfig {
+    defaultLocale: string;
+    locales: string[];
+}
+export interface AkanI18nConfigInput {
+    defaultLocale?: string;
+    locales?: readonly string[];
+}
+export declare const DEFAULT_AKAN_I18N: AkanI18nConfig;
+export declare function resolveAkanI18nConfig(input?: AkanI18nConfigInput): AkanI18nConfig;
+export declare function parseAkanI18nEnv(env?: Record<string, string | undefined>): AkanI18nConfig;

package/types/common/lowerlize.d.ts

@@ -0,0 +1,2 @@
+/** Lowercases only the first character of a string. */
+export declare const lowerlize: (str: string) => string;

package/types/common/mergeVersion.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * semantic version 규격에 맞게 조합하는 함수
+ * https://semver.org/
+ * @param major 릴리즈(플랫폼(google,apple,etc...)에 올라가 있는) 버전
+ * @param minor 릴리즈(플랫폼(google,apple,etc...)에 올라가 있는) 버전
+ * @param patch 코드푸시 (Framework 자체 버전)
+ * @returns `major.minor.patch` 형식으로 조합된 버전
+ */
+export declare const mergeVersion: (major: number, minor: number, patch: number) => string;

package/types/common/objectify.d.ts

@@ -0,0 +1 @@
+export declare const objectify: <T extends object>(obj: T, keys?: (keyof T)[]) => Partial<T>;

package/types/common/pathGet.d.ts

@@ -0,0 +1 @@
+export declare const pathGet: (path: string | (string | number)[], obj: unknown, separator?: string, fallback?: unknown) => unknown;

package/types/common/pathSet.d.ts

@@ -0,0 +1,3 @@
+type PathSegment = string | number;
+export declare const pathSet: <T>(obj: T, path: string | readonly PathSegment[], value: unknown) => T;
+export {};

package/types/common/randomPick.d.ts

@@ -0,0 +1 @@
+export declare const randomPick: <T = unknown>(arr: T[] | readonly T[]) => T;

package/types/common/randomPicks.d.ts

@@ -0,0 +1 @@
+export declare const randomPicks: <T>(arr: T[] | readonly T[], count?: number, allowDuplicate?: boolean) => T[];

package/types/common/routeConvention.d.ts

@@ -0,0 +1,35 @@
+export type RouteModuleKind = "page" | "layout";
+export interface ParsedRouteModuleKey {
+    key: string;
+    kind: RouteModuleKind;
+    routeSegments: string[];
+    moduleSegments: string[];
+    sourceRouteSegments: string[];
+    ext: string;
+    leaf: string;
+    pattern: string;
+    isSpecialRoute: boolean;
+    isInternalRootLayout: boolean;
+}
+export interface ValidateSubRoutePageKeyOptions {
+    appName?: string;
+    filePath?: string;
+}
+export interface ValidatePageSourceFileOptions {
+    filePath?: string;
+}
+export declare function isRouteSourceFile(filePath: string): boolean;
+export declare function validatePageSourceFile(filePath: string, options?: ValidatePageSourceFileOptions): boolean;
+export declare function validateSubRoutePageKey(key: string, basePaths: Iterable<string>, options?: ValidateSubRoutePageKeyOptions): void;
+export declare function parseRouteModuleKey(key: string): ParsedRouteModuleKey;
+export declare function isSpecialRouteLeaf(leaf: string): boolean;
+export declare function tryParseRouteModuleKey(key: string): ParsedRouteModuleKey | null;
+export declare function normalizeRoutePattern(segments: string[]): string;
+export declare function routeSegmentToPatternPart(segment: string): string;
+export declare function routeSegmentToTreePath(segment: string): string;
+export declare function compareRouteSpecificity(a: string, b: string): number;
+export declare function matchRoutePattern(pattern: string, pathname: string): Record<string, string> | null;
+export declare function assertUniqueRoutePatterns(entries: {
+    key: string;
+    pattern: string;
+}[]): void;

package/types/common/sleep.d.ts

@@ -0,0 +1,2 @@
+/** Resolves after the requested delay in milliseconds. */
+export declare const sleep: (ms: number) => Promise<unknown>;

package/types/common/splitVersion.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * semantic version 규격에 맞게 major, minor, patch로 나누는 함수
+ * https://semver.org/
+ * @params version `major.minor.patch` 형식으로 조합된 버전
+ */
+export declare const splitVersion: (version: string) => {
+    major: string;
+    minor: string;
+    patch: string;
+};

package/types/common/subRoute.d.ts

@@ -0,0 +1,7 @@
+import type { AkanI18nConfig } from "./localeConfig.d.ts";
+export declare const parseBasePaths: (value: string | string[] | Set<string> | undefined | null) => string[];
+export declare const getBasePathFromPathname: (pathname: string, { basePaths, i18n, headerBasePath, }: {
+    basePaths: Iterable<string>;
+    i18n?: Pick<AkanI18nConfig, "locales" | "defaultLocale">;
+    headerBasePath?: string | null;
+}) => string | null;

package/types/common/types.d.ts

@@ -0,0 +1,14 @@
+export interface FetchPolicy<Returns = unknown> {
+    cache?: boolean | number;
+    crystalize?: boolean;
+    origin?: string;
+    onError?: (error: string) => void;
+    token?: string;
+    partial?: string[];
+    timeout?: number;
+}
+export type SnakeCase<S extends string> = S extends `${infer T}_${infer U}` ? `${Lowercase<T>}_${SnakeCase<U>}` : S;
+export type SnakeCaseObj<T> = {
+    [K in keyof T as SnakeCase<K & string>]: T[K] extends object ? SnakeCaseObj<T[K]> : T[K];
+};
+export type SnakeMsg<Msg> = SnakeCaseObj<Msg>;

package/types/common.d.ts

@@ -0,0 +1 @@
+export * from "./common/index.d.ts";