@cyberskill/shared 1.66.0 → 1.67.0

package/dist/_tsup-dts-rollup.d.cts

@@ -5,7 +5,7 @@ import type { AggregatePaginateResult } from 'mongoose';
 import { ApolloCache } from '@apollo/client';
 import { ApolloClient } from '@apollo/client';
 import { ApolloClientOptions } from '@apollo/client';
-import type { ApolloError } from '@apollo/client';
+import type { ApolloError as ApolloError_2 } from '@apollo/client';
 import type { ApolloLink } from '@apollo/client';
 import type { ClientSession } from 'mongoose';
 import type { CodegenConfig } from '@graphql-codegen/cli';
@@ -20,7 +20,9 @@ import type { ErrorHandlingMiddlewareFunction } from 'mongoose';
 import type { ErrorHandlingMiddlewareWithOption } from 'mongoose';
 import type { Filter } from 'mongodb';
 import type { FilterQuery } from 'mongoose';
-import { I_Command as I_Command_3 } from '#typescript/command.js';
+import { I_ApolloErrorContext as I_ApolloErrorContext_2 } from './apollo-error.type.js';
+import { I_Command as I_Command_2 } from './command.type.js';
+import { I_LoadingContext as I_LoadingContext_2 } from './loading.type.js';
 import type { InitOptions } from 'i18next';
 import type { InsertManyOptions } from 'mongoose';
 import type { InsertManyResult } from 'mongodb';
@@ -63,35 +65,48 @@ import type { WithId } from 'mongodb';
 export { aggregatePaginate }
 export { aggregatePaginate as aggregatePaginate_alias_1 }
 export { aggregatePaginate as aggregatePaginate_alias_2 }
+export { aggregatePaginate as aggregatePaginate_alias_3 }
 
 export { ApolloCache }
 export { ApolloCache as ApolloCache_alias_1 }
 export { ApolloCache as ApolloCache_alias_2 }
+export { ApolloCache as ApolloCache_alias_3 }
 
 export { ApolloClient }
 export { ApolloClient as ApolloClient_alias_1 }
 export { ApolloClient as ApolloClient_alias_2 }
+export { ApolloClient as ApolloClient_alias_3 }
 
 export { ApolloClientOptions }
 export { ApolloClientOptions as ApolloClientOptions_alias_1 }
 export { ApolloClientOptions as ApolloClientOptions_alias_2 }
+export { ApolloClientOptions as ApolloClientOptions_alias_3 }
 
-declare function ApolloErrorViewerModal(): JSX_2.Element | null;
-export { ApolloErrorViewerModal }
-export { ApolloErrorViewerModal as ApolloErrorViewerModal_alias_1 }
-export { ApolloErrorViewerModal as ApolloErrorViewerModal_alias_2 }
+declare function ApolloError(): JSX_2.Element | null;
+export { ApolloError }
+export { ApolloError as ApolloError_alias_1 }
+export { ApolloError as ApolloError_alias_2 }
+export { ApolloError as ApolloError_alias_3 }
 
-declare function ApolloErrorViewerProvider({ children }: {
+declare const ApolloErrorContext: Context<I_ApolloErrorContext | undefined>;
+export { ApolloErrorContext }
+export { ApolloErrorContext as ApolloErrorContext_alias_1 }
+export { ApolloErrorContext as ApolloErrorContext_alias_2 }
+export { ApolloErrorContext as ApolloErrorContext_alias_3 }
+
+declare function ApolloErrorProvider({ children }: {
     children: ReactNode;
 }): JSX_2.Element;
-export { ApolloErrorViewerProvider }
-export { ApolloErrorViewerProvider as ApolloErrorViewerProvider_alias_1 }
-export { ApolloErrorViewerProvider as ApolloErrorViewerProvider_alias_2 }
+export { ApolloErrorProvider }
+export { ApolloErrorProvider as ApolloErrorProvider_alias_1 }
+export { ApolloErrorProvider as ApolloErrorProvider_alias_2 }
+export { ApolloErrorProvider as ApolloErrorProvider_alias_3 }
 
-declare function ApolloProvider({ isNextJS, options, children, client: CustomClient, provider: CustomProvider, cache: CustomCache, }: I_ApolloProviderProps_2): JSX_2.Element;
+declare function ApolloProvider({ isNextJS, options, children, client: CustomClient, provider: CustomProvider, cache: CustomCache, }: I_ApolloProviderProps): JSX_2.Element;
 export { ApolloProvider }
 export { ApolloProvider as ApolloProvider_alias_1 }
 export { ApolloProvider as ApolloProvider_alias_2 }
+export { ApolloProvider as ApolloProvider_alias_3 }
 
 declare function appendFileSync(filePath: string, data: string | T_Object_2, options?: {
     isJson?: boolean;
@@ -99,56 +114,61 @@ declare function appendFileSync(filePath: string, data: string | T_Object_2, opt
 export { appendFileSync }
 export { appendFileSync as appendFileSync_alias_1 }
 export { appendFileSync as appendFileSync_alias_2 }
+export { appendFileSync as appendFileSync_alias_3 }
 
 declare const BUILD_DIRECTORY = "dist";
 export { BUILD_DIRECTORY }
 export { BUILD_DIRECTORY as BUILD_DIRECTORY_alias_1 }
 export { BUILD_DIRECTORY as BUILD_DIRECTORY_alias_2 }
+export { BUILD_DIRECTORY as BUILD_DIRECTORY_alias_3 }
 
 declare class C_Collection<T extends Partial<C_Document>> extends Collection<T> {
 }
 export { C_Collection }
 export { C_Collection as C_Collection_alias_1 }
 export { C_Collection as C_Collection_alias_2 }
+export { C_Collection as C_Collection_alias_3 }
 
 declare class C_Db extends Db {
 }
 export { C_Db }
 export { C_Db as C_Db_alias_1 }
 export { C_Db as C_Db_alias_2 }
-
-declare class C_Db_2 extends Db { }
+export { C_Db as C_Db_alias_3 }
 
 declare class C_Document extends Document_2 {
 }
 export { C_Document }
 export { C_Document as C_Document_alias_1 }
 export { C_Document as C_Document_alias_2 }
-
-declare class C_Document_2 extends Document_2 { }
+export { C_Document as C_Document_alias_3 }
 
 declare class C_Model extends Model {
 }
 export { C_Model }
 export { C_Model as C_Model_alias_1 }
 export { C_Model as C_Model_alias_2 }
+export { C_Model as C_Model_alias_3 }
 
-declare const CHECK_PACKAGE_EMPTY_RESULT: I_CheckPackage_2;
+declare const CHECK_PACKAGE_EMPTY_RESULT: I_CheckPackage;
 export { CHECK_PACKAGE_EMPTY_RESULT }
 export { CHECK_PACKAGE_EMPTY_RESULT as CHECK_PACKAGE_EMPTY_RESULT_alias_1 }
 export { CHECK_PACKAGE_EMPTY_RESULT as CHECK_PACKAGE_EMPTY_RESULT_alias_2 }
+export { CHECK_PACKAGE_EMPTY_RESULT as CHECK_PACKAGE_EMPTY_RESULT_alias_3 }
 
 declare function checkPackage(packageName: string, options?: {
     update?: boolean;
-}): Promise<I_CheckPackage_2>;
+}): Promise<I_CheckPackage>;
 export { checkPackage }
 export { checkPackage as checkPackage_alias_1 }
 export { checkPackage as checkPackage_alias_2 }
+export { checkPackage as checkPackage_alias_3 }
 
 declare function clearAllErrorLists(): Promise<void>;
 export { clearAllErrorLists }
 export { clearAllErrorLists as clearAllErrorLists_alias_1 }
 export { clearAllErrorLists as clearAllErrorLists_alias_2 }
+export { clearAllErrorLists as clearAllErrorLists_alias_3 }
 
 declare const COMMAND: {
     SIMPLE_GIT_HOOKS: string;
@@ -173,6 +193,7 @@ declare const COMMAND: {
 export { COMMAND }
 export { COMMAND as COMMAND_alias_1 }
 export { COMMAND as COMMAND_alias_2 }
+export { COMMAND as COMMAND_alias_3 }
 
 declare const COMMAND_DESCRIPTIONS: {
     lint: string;
@@ -189,18 +210,21 @@ declare const COMMAND_DESCRIPTIONS: {
 export { COMMAND_DESCRIPTIONS }
 export { COMMAND_DESCRIPTIONS as COMMAND_DESCRIPTIONS_alias_1 }
 export { COMMAND_DESCRIPTIONS as COMMAND_DESCRIPTIONS_alias_2 }
+export { COMMAND_DESCRIPTIONS as COMMAND_DESCRIPTIONS_alias_3 }
 
 declare const COMMIT_LINT_CLI = "commitlint";
 export { COMMIT_LINT_CLI }
 export { COMMIT_LINT_CLI as COMMIT_LINT_CLI_alias_1 }
 export { COMMIT_LINT_CLI as COMMIT_LINT_CLI_alias_2 }
+export { COMMIT_LINT_CLI as COMMIT_LINT_CLI_alias_3 }
 
 declare const COMMIT_LINT_PACKAGE_NAME = "@commitlint/cli";
 export { COMMIT_LINT_PACKAGE_NAME }
 export { COMMIT_LINT_PACKAGE_NAME as COMMIT_LINT_PACKAGE_NAME_alias_1 }
 export { COMMIT_LINT_PACKAGE_NAME as COMMIT_LINT_PACKAGE_NAME_alias_2 }
+export { COMMIT_LINT_PACKAGE_NAME as COMMIT_LINT_PACKAGE_NAME_alias_3 }
 
-declare function createGraphqlCodegenConfig({ uri, from, to, withComponent, withHOC, withHooks, withMutationFn, withRefetchFn, }: I_GraphqlCodegenConfig_2): CodegenConfig;
+declare function createGraphqlCodegenConfig({ uri, from, to, withComponent, withHOC, withHooks, withMutationFn, withRefetchFn, }: I_GraphqlCodegenConfig): CodegenConfig;
 export { createGraphqlCodegenConfig }
 export { createGraphqlCodegenConfig as createGraphqlCodegenConfig_alias_1 }
 
@@ -208,21 +232,31 @@ declare const CYBERSKILL_CLI = "cyberskill";
 export { CYBERSKILL_CLI }
 export { CYBERSKILL_CLI as CYBERSKILL_CLI_alias_1 }
 export { CYBERSKILL_CLI as CYBERSKILL_CLI_alias_2 }
+export { CYBERSKILL_CLI as CYBERSKILL_CLI_alias_3 }
+
+declare const CYBERSKILL_CLI_PATH = "src/nodejs/cli/index.ts";
+export { CYBERSKILL_CLI_PATH }
+export { CYBERSKILL_CLI_PATH as CYBERSKILL_CLI_PATH_alias_1 }
+export { CYBERSKILL_CLI_PATH as CYBERSKILL_CLI_PATH_alias_2 }
+export { CYBERSKILL_CLI_PATH as CYBERSKILL_CLI_PATH_alias_3 }
 
 declare const CYBERSKILL_DIRECTORY: string;
 export { CYBERSKILL_DIRECTORY }
 export { CYBERSKILL_DIRECTORY as CYBERSKILL_DIRECTORY_alias_1 }
 export { CYBERSKILL_DIRECTORY as CYBERSKILL_DIRECTORY_alias_2 }
+export { CYBERSKILL_DIRECTORY as CYBERSKILL_DIRECTORY_alias_3 }
 
 declare const CYBERSKILL_PACKAGE_NAME = "@cyberskill/shared";
 export { CYBERSKILL_PACKAGE_NAME }
 export { CYBERSKILL_PACKAGE_NAME as CYBERSKILL_PACKAGE_NAME_alias_1 }
 export { CYBERSKILL_PACKAGE_NAME as CYBERSKILL_PACKAGE_NAME_alias_2 }
+export { CYBERSKILL_PACKAGE_NAME as CYBERSKILL_PACKAGE_NAME_alias_3 }
 
 declare const CYBERSKILL_STORAGE = ".cyberskill-storage";
 export { CYBERSKILL_STORAGE }
 export { CYBERSKILL_STORAGE as CYBERSKILL_STORAGE_alias_1 }
 export { CYBERSKILL_STORAGE as CYBERSKILL_STORAGE_alias_2 }
+export { CYBERSKILL_STORAGE as CYBERSKILL_STORAGE_alias_3 }
 
 declare const DEBUG: boolean;
 export { DEBUG }
@@ -233,6 +267,7 @@ declare function deepMerge(...object: T_Object_2[]): T_Object_2;
 export { deepMerge }
 export { deepMerge as deepMerge_alias_1 }
 export { deepMerge as deepMerge_alias_2 }
+export { deepMerge as deepMerge_alias_3 }
 
 export declare const default_alias: {
     extends: string[];
@@ -1396,10 +1431,6 @@ export declare const default_alias_2: {
     '*': string[];
 };
 
-export declare const default_alias_3: (options: UserConfig) => UserConfig;
-
-export declare const default_alias_4: (options: UserConfig) => UserConfig;
-
 declare enum E_CommandType {
     PNPM_ADD_AND_EXEC = "PNPM_ADD_AND_EXEC",
     PNPM_ADD_DEV_AND_EXEC = "PNPM_ADD_DEV_AND_EXEC",
@@ -1408,6 +1439,7 @@ declare enum E_CommandType {
 export { E_CommandType }
 export { E_CommandType as E_CommandType_alias_1 }
 export { E_CommandType as E_CommandType_alias_2 }
+export { E_CommandType as E_CommandType_alias_3 }
 
 declare enum E_ConfigType {
     ESLINT = "eslint",
@@ -1420,14 +1452,6 @@ export { E_ConfigType }
 export { E_ConfigType as E_ConfigType_alias_1 }
 export { E_ConfigType as E_ConfigType_alias_2 }
 
-declare enum E_ConfigType_2 {
-    ESLINT = 'eslint',
-    COMMITLINT = 'commitlint',
-    LINT_STAGED = 'lint-staged',
-    VITEST_REACT_E2E = 'vitest-react-e2e',
-    VITEST_REACT_UNIT = 'vitest-react-unit',
-}
-
 declare enum E_IssueType {
     Error = "error",
     Warning = "warning"
@@ -1435,103 +1459,111 @@ declare enum E_IssueType {
 export { E_IssueType }
 export { E_IssueType as E_IssueType_alias_1 }
 export { E_IssueType as E_IssueType_alias_2 }
-
-declare enum E_IssueType_2 {
-    Error = 'error',
-    Warning = 'warning',
-}
+export { E_IssueType as E_IssueType_alias_3 }
 
 declare const ESLINT_CLI = "eslint";
 export { ESLINT_CLI }
 export { ESLINT_CLI as ESLINT_CLI_alias_1 }
 export { ESLINT_CLI as ESLINT_CLI_alias_2 }
+export { ESLINT_CLI as ESLINT_CLI_alias_3 }
 
 declare const ESLINT_INSPECT_CLI = "eslint-config-inspector";
 export { ESLINT_INSPECT_CLI }
 export { ESLINT_INSPECT_CLI as ESLINT_INSPECT_CLI_alias_1 }
 export { ESLINT_INSPECT_CLI as ESLINT_INSPECT_CLI_alias_2 }
+export { ESLINT_INSPECT_CLI as ESLINT_INSPECT_CLI_alias_3 }
 
 declare const ESLINT_INSPECT_PACKAGE_NAME = "@eslint/config-inspector";
 export { ESLINT_INSPECT_PACKAGE_NAME }
 export { ESLINT_INSPECT_PACKAGE_NAME as ESLINT_INSPECT_PACKAGE_NAME_alias_1 }
 export { ESLINT_INSPECT_PACKAGE_NAME as ESLINT_INSPECT_PACKAGE_NAME_alias_2 }
+export { ESLINT_INSPECT_PACKAGE_NAME as ESLINT_INSPECT_PACKAGE_NAME_alias_3 }
 
 declare const ESLINT_PACKAGE_NAME = "eslint";
 export { ESLINT_PACKAGE_NAME }
 export { ESLINT_PACKAGE_NAME as ESLINT_PACKAGE_NAME_alias_1 }
 export { ESLINT_PACKAGE_NAME as ESLINT_PACKAGE_NAME_alias_2 }
+export { ESLINT_PACKAGE_NAME as ESLINT_PACKAGE_NAME_alias_3 }
 
 declare function executeCommand(command: string, parser?: typeof parseCommandOutput): Promise<void>;
 export { executeCommand }
 export { executeCommand as executeCommand_alias_1 }
 export { executeCommand as executeCommand_alias_2 }
+export { executeCommand as executeCommand_alias_3 }
 
 declare function existsSync(...paths: string[]): boolean;
 export { existsSync }
 export { existsSync as existsSync_alias_1 }
 export { existsSync as existsSync_alias_2 }
+export { existsSync as existsSync_alias_3 }
 
-declare function formatCommand(command: T_Command_2, context?: I_CommandContext_2): string | I_Command_3;
+declare function formatCommand(command: T_Command, context?: I_CommandContext): string | I_Command_2;
 export { formatCommand }
 export { formatCommand as formatCommand_alias_1 }
 export { formatCommand as formatCommand_alias_2 }
+export { formatCommand as formatCommand_alias_3 }
 
 declare function generateShortId(uuid: string, length?: number): string;
 export { generateShortId }
 export { generateShortId as generateShortId_alias_1 }
 export { generateShortId as generateShortId_alias_2 }
+export { generateShortId as generateShortId_alias_3 }
 
-declare function generateSlug(str?: string, options?: I_SlugifyOptions_2): string;
+declare function generateSlug(str?: string, options?: I_SlugifyOptions): string;
 export { generateSlug }
 export { generateSlug as generateSlug_alias_1 }
 export { generateSlug as generateSlug_alias_2 }
+export { generateSlug as generateSlug_alias_3 }
 
 declare function getLatestPackageVersion(packageName: string): Promise<string>;
 export { getLatestPackageVersion }
 export { getLatestPackageVersion as getLatestPackageVersion_alias_1 }
 export { getLatestPackageVersion as getLatestPackageVersion_alias_2 }
+export { getLatestPackageVersion as getLatestPackageVersion_alias_3 }
 
-declare function getPackage(packageName: string): I_GetPackage_2 | false;
+declare function getPackage(packageName: string): I_GetPackage | false;
 export { getPackage }
 export { getPackage as getPackage_alias_1 }
 export { getPackage as getPackage_alias_2 }
+export { getPackage as getPackage_alias_3 }
 
-declare function getStorageDir(): string;
-export { getStorageDir }
-export { getStorageDir as getStorageDir_alias_1 }
-export { getStorageDir as getStorageDir_alias_2 }
-
-declare function getStoredErrorLists(): Promise<I_IssueEntry_2[]>;
+declare function getStoredErrorLists(): Promise<I_IssueEntry[]>;
 export { getStoredErrorLists }
 export { getStoredErrorLists as getStoredErrorLists_alias_1 }
 export { getStoredErrorLists as getStoredErrorLists_alias_2 }
+export { getStoredErrorLists as getStoredErrorLists_alias_3 }
 
 declare const GIT_CLI = "git";
 export { GIT_CLI }
 export { GIT_CLI as GIT_CLI_alias_1 }
 export { GIT_CLI as GIT_CLI_alias_2 }
+export { GIT_CLI as GIT_CLI_alias_3 }
 
 declare const GIT_COMMIT_EDITMSG = ".git/COMMIT_EDITMSG";
 export { GIT_COMMIT_EDITMSG }
 export { GIT_COMMIT_EDITMSG as GIT_COMMIT_EDITMSG_alias_1 }
 export { GIT_COMMIT_EDITMSG as GIT_COMMIT_EDITMSG_alias_2 }
+export { GIT_COMMIT_EDITMSG as GIT_COMMIT_EDITMSG_alias_3 }
 
 declare const GIT_HOOK = ".git/hooks/";
 export { GIT_HOOK }
 export { GIT_HOOK as GIT_HOOK_alias_1 }
 export { GIT_HOOK as GIT_HOOK_alias_2 }
+export { GIT_HOOK as GIT_HOOK_alias_3 }
 
 declare const GIT_IGNORE = ".gitignore";
 export { GIT_IGNORE }
 export { GIT_IGNORE as GIT_IGNORE_alias_1 }
 export { GIT_IGNORE as GIT_IGNORE_alias_2 }
+export { GIT_IGNORE as GIT_IGNORE_alias_3 }
 
 declare const GRAPHQL_URI_DEFAULT = "/graphql";
 export { GRAPHQL_URI_DEFAULT }
 export { GRAPHQL_URI_DEFAULT as GRAPHQL_URI_DEFAULT_alias_1 }
 export { GRAPHQL_URI_DEFAULT as GRAPHQL_URI_DEFAULT_alias_2 }
+export { GRAPHQL_URI_DEFAULT as GRAPHQL_URI_DEFAULT_alias_3 }
 
-declare function HOOK({ isCurrentProject }: Partial<I_CommandContext_2>): {
+declare function HOOK({ isCurrentProject }: Partial<I_CommandContext>): {
     'pre-push'?: {
         raw: boolean;
         cmd: string;
@@ -1542,21 +1574,17 @@ declare function HOOK({ isCurrentProject }: Partial<I_CommandContext_2>): {
 export { HOOK }
 export { HOOK as HOOK_alias_1 }
 export { HOOK as HOOK_alias_2 }
+export { HOOK as HOOK_alias_3 }
 
-declare interface I_ApolloErrorViewerContext {
-    error: ApolloError | null;
-    showError: (error: ApolloError) => void;
-    hideError: () => void;
-}
-export { I_ApolloErrorViewerContext }
-export { I_ApolloErrorViewerContext as I_ApolloErrorViewerContext_alias_1 }
-export { I_ApolloErrorViewerContext as I_ApolloErrorViewerContext_alias_2 }
-
-declare interface I_ApolloErrorViewerContext_2 {
-    error: ApolloError | null;
-    showError: (error: ApolloError) => void;
+declare interface I_ApolloErrorContext {
+    error: ApolloError_2 | null;
+    showError: (error: ApolloError_2) => void;
     hideError: () => void;
 }
+export { I_ApolloErrorContext }
+export { I_ApolloErrorContext as I_ApolloErrorContext_alias_1 }
+export { I_ApolloErrorContext as I_ApolloErrorContext_alias_2 }
+export { I_ApolloErrorContext as I_ApolloErrorContext_alias_3 }
 
 declare interface I_ApolloOptions extends Omit<ApolloClientOptions<NormalizedCacheObject>, 'cache'> {
     uri?: string;
@@ -1568,17 +1596,9 @@ declare interface I_ApolloOptions extends Omit<ApolloClientOptions<NormalizedCac
 export { I_ApolloOptions }
 export { I_ApolloOptions as I_ApolloOptions_alias_1 }
 export { I_ApolloOptions as I_ApolloOptions_alias_2 }
+export { I_ApolloOptions as I_ApolloOptions_alias_3 }
 
-declare interface I_ApolloOptions_2 extends Omit<ApolloClientOptions<NormalizedCacheObject>, 'cache'> {
-    uri?: string;
-    wsUrl?: string;
-    cache?: ApolloCache<NormalizedCacheObject>;
-    customLinks?: ApolloLink[];
-    ssrMode?: boolean;
-}
-
-declare interface I_ApolloProviderProps {
-    children: T_Children;
+declare interface I_ApolloProviderProps extends I_Children_2 {
     isNextJS?: boolean;
     options?: I_ApolloOptions;
     client?: ApolloClient<NormalizedCacheObject>;
@@ -1589,16 +1609,7 @@ declare interface I_ApolloProviderProps {
 export { I_ApolloProviderProps }
 export { I_ApolloProviderProps as I_ApolloProviderProps_alias_1 }
 export { I_ApolloProviderProps as I_ApolloProviderProps_alias_2 }
-
-declare interface I_ApolloProviderProps_2 {
-    children: T_Children_2;
-    isNextJS?: boolean;
-    options?: I_ApolloOptions_2;
-    client?: ApolloClient<NormalizedCacheObject>;
-    makeClient?: () => ApolloClient<NormalizedCacheObject>;
-    provider?: ComponentType<I_ApolloProviderProps_2>;
-    cache?: ApolloCache<NormalizedCacheObject>;
-}
+export { I_ApolloProviderProps as I_ApolloProviderProps_alias_3 }
 
 declare interface I_CheckPackage {
     isCurrentProject: boolean;
@@ -1609,12 +1620,17 @@ declare interface I_CheckPackage {
 export { I_CheckPackage }
 export { I_CheckPackage as I_CheckPackage_alias_1 }
 export { I_CheckPackage as I_CheckPackage_alias_2 }
+export { I_CheckPackage as I_CheckPackage_alias_3 }
 
-declare interface I_CheckPackage_2 {
-    isCurrentProject: boolean;
-    installedPath: string;
-    file: T_PackageJson_2;
-    isUpToDate: boolean;
+declare interface I_Children {
+    children: T_Children;
+}
+export { I_Children }
+export { I_Children as I_Children_alias_1 }
+export { I_Children as I_Children_alias_2 }
+
+declare interface I_Children_2 {
+    children: T_Children_2;
 }
 
 declare interface I_Command {
@@ -1624,8 +1640,7 @@ declare interface I_Command {
 export { I_Command }
 export { I_Command as I_Command_alias_1 }
 export { I_Command as I_Command_alias_2 }
-
-declare interface I_Command_2 { raw: boolean; cmd: string }
+export { I_Command as I_Command_alias_3 }
 
 declare interface I_CommandContext {
     isRemote: boolean;
@@ -1634,11 +1649,7 @@ declare interface I_CommandContext {
 export { I_CommandContext }
 export { I_CommandContext as I_CommandContext_alias_1 }
 export { I_CommandContext as I_CommandContext_alias_2 }
-
-declare interface I_CommandContext_2 {
-    isRemote: boolean;
-    isCurrentProject: boolean;
-}
+export { I_CommandContext as I_CommandContext_alias_3 }
 
 declare interface I_CreateModelOptions<T extends Partial<C_Document>> extends I_MongooseOptions<T> {
     schema: T_Input_MongooseSchema<T>;
@@ -1650,15 +1661,7 @@ declare interface I_CreateModelOptions<T extends Partial<C_Document>> extends I_
 export { I_CreateModelOptions }
 export { I_CreateModelOptions as I_CreateModelOptions_alias_1 }
 export { I_CreateModelOptions as I_CreateModelOptions_alias_2 }
-
-declare interface I_CreateModelOptions_2<T extends Partial<C_Document_2>>
-extends I_MongooseOptions_2<T> {
-    schema: T_Input_MongooseSchema_2<T>;
-    name: string;
-    aggregate?: boolean;
-    middlewares?: I_MongooseModelMiddleware_2<T>[];
-    pagination?: boolean;
-}
+export { I_CreateModelOptions as I_CreateModelOptions_alias_3 }
 
 declare interface I_CreateSchemaOptions<T extends Partial<C_Document>> extends I_MongooseOptions<T> {
     schema: T_Input_MongooseSchema<T>;
@@ -1667,12 +1670,7 @@ declare interface I_CreateSchemaOptions<T extends Partial<C_Document>> extends I
 export { I_CreateSchemaOptions }
 export { I_CreateSchemaOptions as I_CreateSchemaOptions_alias_1 }
 export { I_CreateSchemaOptions as I_CreateSchemaOptions_alias_2 }
-
-declare interface I_CreateSchemaOptions_2<T extends Partial<C_Document_2>>
-extends I_MongooseOptions_2<T> {
-    schema: T_Input_MongooseSchema_2<T>;
-    standalone?: boolean;
-}
+export { I_CreateSchemaOptions as I_CreateSchemaOptions_alias_3 }
 
 declare interface I_DeleteOptionsExtended extends Omit<QueryOptions, 'session'> {
     session?: ClientSession;
@@ -1680,10 +1678,7 @@ declare interface I_DeleteOptionsExtended extends Omit<QueryOptions, 'session'>
 export { I_DeleteOptionsExtended }
 export { I_DeleteOptionsExtended as I_DeleteOptionsExtended_alias_1 }
 export { I_DeleteOptionsExtended as I_DeleteOptionsExtended_alias_2 }
-
-declare interface I_DeleteOptionsExtended_2 extends Omit<QueryOptions, 'session'> {
-    session?: ClientSession;
-}
+export { I_DeleteOptionsExtended as I_DeleteOptionsExtended_alias_3 }
 
 declare interface I_EslintError {
     filePath: string;
@@ -1698,16 +1693,14 @@ declare interface I_EslintError {
 export { I_EslintError }
 export { I_EslintError as I_EslintError_alias_1 }
 export { I_EslintError as I_EslintError_alias_2 }
+export { I_EslintError as I_EslintError_alias_3 }
 
 declare interface I_ExtendedModel<T extends Partial<C_Document>> extends Model<T>, PaginateModel<T>, AggregatePaginateModel<T> {
 }
 export { I_ExtendedModel }
 export { I_ExtendedModel as I_ExtendedModel_alias_1 }
 export { I_ExtendedModel as I_ExtendedModel_alias_2 }
-
-declare interface I_ExtendedModel_2<T extends Partial<C_Document_2>>
-extends Model<T>, PaginateModel<T>,
-AggregatePaginateModel<T> { }
+export { I_ExtendedModel as I_ExtendedModel_alias_3 }
 
 declare interface I_GenericDocument extends Partial<C_Document> {
     id: string;
@@ -1718,13 +1711,7 @@ declare interface I_GenericDocument extends Partial<C_Document> {
 export { I_GenericDocument }
 export { I_GenericDocument as I_GenericDocument_alias_1 }
 export { I_GenericDocument as I_GenericDocument_alias_2 }
-
-declare interface I_GenericDocument_2 extends Partial<C_Document_2> {
-    id: string;
-    isDel: boolean;
-    createdAt: string | Date;
-    updatedAt: string | Date;
-}
+export { I_GenericDocument as I_GenericDocument_alias_3 }
 
 declare interface I_GetPackage {
     path: string;
@@ -1736,14 +1723,7 @@ declare interface I_GetPackage {
 export { I_GetPackage }
 export { I_GetPackage as I_GetPackage_alias_1 }
 export { I_GetPackage as I_GetPackage_alias_2 }
-
-declare interface I_GetPackage_2 {
-    path: string;
-    file: T_PackageJson_2;
-    isCurrentProject: boolean;
-    isDepend: boolean;
-    isDevDepend: boolean;
-}
+export { I_GetPackage as I_GetPackage_alias_3 }
 
 declare interface I_GraphqlCodegenConfig {
     uri: string;
@@ -1757,18 +1737,6 @@ declare interface I_GraphqlCodegenConfig {
 }
 export { I_GraphqlCodegenConfig }
 export { I_GraphqlCodegenConfig as I_GraphqlCodegenConfig_alias_1 }
-export { I_GraphqlCodegenConfig as I_GraphqlCodegenConfig_alias_2 }
-
-declare interface I_GraphqlCodegenConfig_2 {
-    uri: string;
-    from: string;
-    to: string;
-    withComponent?: boolean;
-    withHOC?: boolean;
-    withHooks?: boolean;
-    withMutationFn?: boolean;
-    withRefetchFn?: boolean;
-}
 
 declare interface I_Input_CreateMany<T> {
     docs: T[];
@@ -1776,6 +1744,7 @@ declare interface I_Input_CreateMany<T> {
 export { I_Input_CreateMany }
 export { I_Input_CreateMany as I_Input_CreateMany_alias_1 }
 export { I_Input_CreateMany as I_Input_CreateMany_alias_2 }
+export { I_Input_CreateMany as I_Input_CreateMany_alias_3 }
 
 declare interface I_Input_CreateOne<T> {
     doc: T;
@@ -1783,6 +1752,7 @@ declare interface I_Input_CreateOne<T> {
 export { I_Input_CreateOne }
 export { I_Input_CreateOne as I_Input_CreateOne_alias_1 }
 export { I_Input_CreateOne as I_Input_CreateOne_alias_2 }
+export { I_Input_CreateOne as I_Input_CreateOne_alias_3 }
 
 declare interface I_Input_DeleteMany<T> {
     filter: T_FilterQuery<T>;
@@ -1791,6 +1761,7 @@ declare interface I_Input_DeleteMany<T> {
 export { I_Input_DeleteMany }
 export { I_Input_DeleteMany as I_Input_DeleteMany_alias_1 }
 export { I_Input_DeleteMany as I_Input_DeleteMany_alias_2 }
+export { I_Input_DeleteMany as I_Input_DeleteMany_alias_3 }
 
 declare interface I_Input_DeleteOne<T> {
     filter: T_FilterQuery<T>;
@@ -1799,6 +1770,7 @@ declare interface I_Input_DeleteOne<T> {
 export { I_Input_DeleteOne }
 export { I_Input_DeleteOne as I_Input_DeleteOne_alias_1 }
 export { I_Input_DeleteOne as I_Input_DeleteOne_alias_2 }
+export { I_Input_DeleteOne as I_Input_DeleteOne_alias_3 }
 
 declare interface I_Input_FindAll<T> extends T_PopulateOption {
     filter: T_FilterQuery<T>;
@@ -1808,6 +1780,7 @@ declare interface I_Input_FindAll<T> extends T_PopulateOption {
 export { I_Input_FindAll }
 export { I_Input_FindAll as I_Input_FindAll_alias_1 }
 export { I_Input_FindAll as I_Input_FindAll_alias_2 }
+export { I_Input_FindAll as I_Input_FindAll_alias_3 }
 
 declare interface I_Input_FindOne<T> extends T_PopulateOption {
     filter: T_FilterQuery<T>;
@@ -1817,6 +1790,7 @@ declare interface I_Input_FindOne<T> extends T_PopulateOption {
 export { I_Input_FindOne }
 export { I_Input_FindOne as I_Input_FindOne_alias_1 }
 export { I_Input_FindOne as I_Input_FindOne_alias_2 }
+export { I_Input_FindOne as I_Input_FindOne_alias_3 }
 
 declare interface I_Input_FindPaging<T> {
     filter?: T_FilterQuery<T>;
@@ -1825,6 +1799,7 @@ declare interface I_Input_FindPaging<T> {
 export { I_Input_FindPaging }
 export { I_Input_FindPaging as I_Input_FindPaging_alias_1 }
 export { I_Input_FindPaging as I_Input_FindPaging_alias_2 }
+export { I_Input_FindPaging as I_Input_FindPaging_alias_3 }
 
 declare interface I_Input_FindPagingAggregate {
     pipeline: T_PipelineStage[];
@@ -1833,6 +1808,7 @@ declare interface I_Input_FindPagingAggregate {
 export { I_Input_FindPagingAggregate }
 export { I_Input_FindPagingAggregate as I_Input_FindPagingAggregate_alias_1 }
 export { I_Input_FindPagingAggregate as I_Input_FindPagingAggregate_alias_2 }
+export { I_Input_FindPagingAggregate as I_Input_FindPagingAggregate_alias_3 }
 
 declare interface I_Input_UpdateMany<T> extends T_PopulateOption {
     filter: T_FilterQuery<T>;
@@ -1842,6 +1818,7 @@ declare interface I_Input_UpdateMany<T> extends T_PopulateOption {
 export { I_Input_UpdateMany }
 export { I_Input_UpdateMany as I_Input_UpdateMany_alias_1 }
 export { I_Input_UpdateMany as I_Input_UpdateMany_alias_2 }
+export { I_Input_UpdateMany as I_Input_UpdateMany_alias_3 }
 
 declare interface I_Input_UpdateOne<T> extends T_PopulateOption {
     filter: T_FilterQuery<T>;
@@ -1851,6 +1828,7 @@ declare interface I_Input_UpdateOne<T> extends T_PopulateOption {
 export { I_Input_UpdateOne }
 export { I_Input_UpdateOne as I_Input_UpdateOne_alias_1 }
 export { I_Input_UpdateOne as I_Input_UpdateOne_alias_2 }
+export { I_Input_UpdateOne as I_Input_UpdateOne_alias_3 }
 
 declare interface I_IssueEntry {
     type: E_IssueType;
@@ -1862,14 +1840,7 @@ declare interface I_IssueEntry {
 export { I_IssueEntry }
 export { I_IssueEntry as I_IssueEntry_alias_1 }
 export { I_IssueEntry as I_IssueEntry_alias_2 }
-
-declare interface I_IssueEntry_2 {
-    type: E_IssueType_2;
-    file: string;
-    message: string;
-    position?: string;
-    rule?: string;
-}
+export { I_IssueEntry as I_IssueEntry_alias_3 }
 
 declare interface I_LoadingContext {
     isLoading: boolean;
@@ -1880,13 +1851,7 @@ declare interface I_LoadingContext {
 export { I_LoadingContext }
 export { I_LoadingContext as I_LoadingContext_alias_1 }
 export { I_LoadingContext as I_LoadingContext_alias_2 }
-
-declare interface I_LoadingContext_2 {
-    isLoading: boolean;
-    isGlobalLoading: boolean;
-    showLoading: (global?: boolean) => void;
-    hideLoading: () => void;
-}
+export { I_LoadingContext as I_LoadingContext_alias_3 }
 
 declare interface I_LoadingProps {
     full?: boolean;
@@ -1897,13 +1862,7 @@ declare interface I_LoadingProps {
 export { I_LoadingProps }
 export { I_LoadingProps as I_LoadingProps_alias_1 }
 export { I_LoadingProps as I_LoadingProps_alias_2 }
-
-declare interface I_LoadingProps_2 {
-    full?: boolean;
-    block?: boolean;
-    className?: string;
-    message?: string;
-}
+export { I_LoadingProps as I_LoadingProps_alias_3 }
 
 declare interface I_Log {
     silent: typeof consola['silent'];
@@ -1924,6 +1883,7 @@ declare interface I_Log {
 export { I_Log }
 export { I_Log as I_Log_alias_1 }
 export { I_Log as I_Log_alias_2 }
+export { I_Log as I_Log_alias_3 }
 
 declare interface I_Log_2 {
     silent: typeof consola['silent'];
@@ -1942,20 +1902,13 @@ declare interface I_Log_2 {
     verbose: typeof consola['verbose'];
 }
 
-declare interface I_Log_NodeJS extends I_Log {
+declare interface I_Log_NodeJS extends I_Log_2 {
     printBoxedLog: (title: string, issues: I_IssueEntry[], color?: string) => void;
 }
 export { I_Log_NodeJS }
 export { I_Log_NodeJS as I_Log_NodeJS_alias_1 }
 export { I_Log_NodeJS as I_Log_NodeJS_alias_2 }
-
-declare interface I_Log_NodeJS_2 extends I_Log_2 {
-    printBoxedLog: (
-    title: string,
-    issues: I_IssueEntry_2[],
-    color?: string,
-    ) => void;
-}
+export { I_Log_NodeJS as I_Log_NodeJS_alias_3 }
 
 declare interface I_MongooseModelMiddleware<T extends Partial<C_Document>> {
     method: T_MongooseMiddlewareMethod;
@@ -1965,48 +1918,30 @@ declare interface I_MongooseModelMiddleware<T extends Partial<C_Document>> {
 export { I_MongooseModelMiddleware }
 export { I_MongooseModelMiddleware as I_MongooseModelMiddleware_alias_1 }
 export { I_MongooseModelMiddleware as I_MongooseModelMiddleware_alias_2 }
-
-declare interface I_MongooseModelMiddleware_2<T extends Partial<C_Document_2>> {
-    method: T_MongooseMiddlewareMethod_2;
-    pre?: T_MongooseMiddlewarePreFunction_2<T & T_QueryWithHelpers_2<T>>;
-    post?: T_MongooseMiddlewarePostFunction_2<T>;
-}
+export { I_MongooseModelMiddleware as I_MongooseModelMiddleware_alias_3 }
 
 declare interface I_MongooseOptions<T extends Partial<C_Document>> {
     mongoose: typeof mongoose;
     virtuals?: {
         name: keyof T | string;
-        options?: I_VirtualOptions_2;
+        options?: I_VirtualOptions;
         get?: (this: T) => void;
     }[];
 }
 export { I_MongooseOptions }
 export { I_MongooseOptions as I_MongooseOptions_alias_1 }
 export { I_MongooseOptions as I_MongooseOptions_alias_2 }
+export { I_MongooseOptions as I_MongooseOptions_alias_3 }
 
-declare interface I_MongooseOptions_2<T extends Partial<C_Document_2>> {
-    mongoose: typeof mongoose;
-    virtuals?: {
-        name: keyof T | string;
-        options?: I_VirtualOptions;
-        get?: (this: T) => void;
-    }[];
-}
-
-declare interface I_NextIntlContextType {
+declare interface I_NextIntlContext {
     languages: I_NextIntlLanguage[];
     currentLanguage?: I_NextIntlLanguage;
     setCurrentLanguage: (newLang: I_NextIntlLanguage) => void;
 }
-export { I_NextIntlContextType }
-export { I_NextIntlContextType as I_NextIntlContextType_alias_1 }
-export { I_NextIntlContextType as I_NextIntlContextType_alias_2 }
-
-declare interface I_NextIntlContextType_2 {
-    languages: I_NextIntlLanguage_2[];
-    currentLanguage?: I_NextIntlLanguage_2;
-    setCurrentLanguage: (newLang: I_NextIntlLanguage_2) => void;
-}
+export { I_NextIntlContext }
+export { I_NextIntlContext as I_NextIntlContext_alias_1 }
+export { I_NextIntlContext as I_NextIntlContext_alias_2 }
+export { I_NextIntlContext as I_NextIntlContext_alias_3 }
 
 declare interface I_NextIntlLanguage {
     label: string;
@@ -2023,26 +1958,22 @@ declare interface I_NextIntlLanguage {
 export { I_NextIntlLanguage }
 export { I_NextIntlLanguage as I_NextIntlLanguage_alias_1 }
 export { I_NextIntlLanguage as I_NextIntlLanguage_alias_2 }
+export { I_NextIntlLanguage as I_NextIntlLanguage_alias_3 }
 
-declare interface I_NextIntlLanguage_2 {
-    label: string;
-    value: string;
-    flag: string;
-    adapterLocale: Locale;
-    icon: string;
-    numberFormat: {
-        code: string;
-        currency: string;
-    };
-    timezone: Timezone;
+declare interface I_NextIntlProviderProps extends I_Children_2 {
+    languages: I_NextIntlLanguage[];
+    messages: T_NextIntlMessageList;
 }
+export { I_NextIntlProviderProps }
+export { I_NextIntlProviderProps as I_NextIntlProviderProps_alias_1 }
+export { I_NextIntlProviderProps as I_NextIntlProviderProps_alias_2 }
+export { I_NextIntlProviderProps as I_NextIntlProviderProps_alias_3 }
 
 declare type I_Return<T = void, E = unknown> = I_ReturnSuccess<T, E> | I_ReturnFailure;
 export { I_Return }
 export { I_Return as I_Return_alias_1 }
 export { I_Return as I_Return_alias_2 }
-
-declare type I_Return_2<T = void, E = unknown> = I_ReturnSuccess_2<T, E> | I_ReturnFailure_2;
+export { I_Return as I_Return_alias_3 }
 
 declare interface I_ReturnFailure {
     success: false;
@@ -2052,12 +1983,7 @@ declare interface I_ReturnFailure {
 export { I_ReturnFailure }
 export { I_ReturnFailure as I_ReturnFailure_alias_1 }
 export { I_ReturnFailure as I_ReturnFailure_alias_2 }
-
-declare interface I_ReturnFailure_2 {
-    success: false;
-    message: string;
-    code: number | string;
-}
+export { I_ReturnFailure as I_ReturnFailure_alias_3 }
 
 declare interface I_ReturnSuccess<T, E = unknown> {
     success: true;
@@ -2068,13 +1994,7 @@ declare interface I_ReturnSuccess<T, E = unknown> {
 export { I_ReturnSuccess }
 export { I_ReturnSuccess as I_ReturnSuccess_alias_1 }
 export { I_ReturnSuccess as I_ReturnSuccess_alias_2 }
-
-declare interface I_ReturnSuccess_2<T, E = unknown> {
-    success: true;
-    result: T & E;
-    message?: string;
-    code?: number | string;
-}
+export { I_ReturnSuccess as I_ReturnSuccess_alias_3 }
 
 declare interface I_Serializer<T> {
     serialize: (value: T) => string;
@@ -2083,6 +2003,7 @@ declare interface I_Serializer<T> {
 export { I_Serializer }
 export { I_Serializer as I_Serializer_alias_1 }
 export { I_Serializer as I_Serializer_alias_2 }
+export { I_Serializer as I_Serializer_alias_3 }
 
 declare interface I_Serializer_2<T> {
     serialize: (value: T) => string;
@@ -2100,15 +2021,7 @@ declare interface I_SlugifyOptions {
 export { I_SlugifyOptions }
 export { I_SlugifyOptions as I_SlugifyOptions_alias_1 }
 export { I_SlugifyOptions as I_SlugifyOptions_alias_2 }
-
-declare interface I_SlugifyOptions_2 {
-    replacement?: string;
-    remove?: RegExp;
-    lower?: boolean;
-    strict?: boolean;
-    locale?: string;
-    trim?: boolean;
-}
+export { I_SlugifyOptions as I_SlugifyOptions_alias_3 }
 
 declare interface I_UpdateOptionsExtended extends Omit<QueryOptions, 'session'> {
     session?: ClientSession;
@@ -2116,19 +2029,12 @@ declare interface I_UpdateOptionsExtended extends Omit<QueryOptions, 'session'>
 export { I_UpdateOptionsExtended }
 export { I_UpdateOptionsExtended as I_UpdateOptionsExtended_alias_1 }
 export { I_UpdateOptionsExtended as I_UpdateOptionsExtended_alias_2 }
-
-declare interface I_UpdateOptionsExtended_2 extends Omit<QueryOptions, 'session'> {
-    session?: ClientSession;
-}
+export { I_UpdateOptionsExtended as I_UpdateOptionsExtended_alias_3 }
 
 declare interface I_VirtualNestedOptions {
     [key: string]: I_VirtualNestedOptions | number | string | boolean;
 }
 
-declare interface I_VirtualNestedOptions_2 {
-    [key: string]: I_VirtualNestedOptions_2 | number | string | boolean;
-}
-
 declare interface I_VirtualOptions {
     ref: string;
     localField: string;
@@ -2138,23 +2044,11 @@ declare interface I_VirtualOptions {
     options?: I_VirtualNestedOptions;
 }
 
-declare interface I_VirtualOptions_2 {
-    ref: string;
-    localField: string;
-    foreignField: string;
-    count?: boolean;
-    justOne?: boolean;
-    options?: I_VirtualNestedOptions_2;
-}
-
 declare function initI18Next(options: InitOptions): Promise<TFunction<"translation", undefined>>;
 export { initI18Next }
 export { initI18Next as initI18Next_alias_1 }
-
-declare function initNodePersist(): Promise<void>;
-export { initNodePersist }
-export { initNodePersist as initNodePersist_alias_1 }
-export { initNodePersist as initNodePersist_alias_2 }
+export { initI18Next as initI18Next_alias_2 }
+export { initI18Next as initI18Next_alias_3 }
 
 declare const IS_BROWSER: boolean;
 export { IS_BROWSER }
@@ -2165,75 +2059,86 @@ declare function isJson(str: string): boolean;
 export { isJson }
 export { isJson as isJson_alias_1 }
 export { isJson as isJson_alias_2 }
+export { isJson as isJson_alias_3 }
 
 declare function isPlainObject(val: unknown): val is T_Object_2;
 export { isPlainObject }
 export { isPlainObject as isPlainObject_alias_1 }
 export { isPlainObject as isPlainObject_alias_2 }
+export { isPlainObject as isPlainObject_alias_3 }
 
 declare function join(...urls: string[]): string;
 export { join }
 export { join as join_alias_1 }
 export { join as join_alias_2 }
+export { join as join_alias_3 }
 
 declare const LINT_STAGED_CLI = "lint-staged";
 export { LINT_STAGED_CLI }
 export { LINT_STAGED_CLI as LINT_STAGED_CLI_alias_1 }
 export { LINT_STAGED_CLI as LINT_STAGED_CLI_alias_2 }
+export { LINT_STAGED_CLI as LINT_STAGED_CLI_alias_3 }
 
 declare const LINT_STAGED_PACKAGE_NAME = "lint-staged";
 export { LINT_STAGED_PACKAGE_NAME }
 export { LINT_STAGED_PACKAGE_NAME as LINT_STAGED_PACKAGE_NAME_alias_1 }
 export { LINT_STAGED_PACKAGE_NAME as LINT_STAGED_PACKAGE_NAME_alias_2 }
+export { LINT_STAGED_PACKAGE_NAME as LINT_STAGED_PACKAGE_NAME_alias_3 }
 
-declare function Loading({ full, block, className, message, ...rest }: I_LoadingProps_2): JSX_2.Element;
+declare function Loading({ full, block, className, message, ...rest }: I_LoadingProps): JSX_2.Element;
 export { Loading }
 export { Loading as Loading_alias_1 }
 export { Loading as Loading_alias_2 }
+export { Loading as Loading_alias_3 }
 
-declare const LoadingContext: Context<I_LoadingContext_2 | undefined>;
+declare const LoadingContext: Context<I_LoadingContext | undefined>;
 export { LoadingContext }
 export { LoadingContext as LoadingContext_alias_1 }
 export { LoadingContext as LoadingContext_alias_2 }
+export { LoadingContext as LoadingContext_alias_3 }
 
-declare function LoadingProvider({ children }: {
-    children: T_Children_2;
-}): JSX_2.Element;
+declare function LoadingProvider({ children }: I_Children_2): JSX_2.Element;
 export { LoadingProvider }
 export { LoadingProvider as LoadingProvider_alias_1 }
 export { LoadingProvider as LoadingProvider_alias_2 }
+export { LoadingProvider as LoadingProvider_alias_3 }
 
-declare const log: I_Log_2;
+declare const log: I_Log;
 export { log }
 export { log as log_alias_1 }
 export { log as log_alias_2 }
+export { log as log_alias_3 }
 
-declare const logNodeJS: I_Log_NodeJS_2;
+declare const logNodeJS: I_Log_NodeJS;
 export { logNodeJS }
 export { logNodeJS as logNodeJS_alias_1 }
 export { logNodeJS as logNodeJS_alias_2 }
+export { logNodeJS as logNodeJS_alias_3 }
 
-export declare function mergeConfigs(type: T_ConfigType_2, ...configs: T_Object_2[]): T_Object_2;
+declare function mergeConfigs(type: T_ConfigType, ...configs: T_Object_2[]): T_Object_2;
+export { mergeConfigs }
+export { mergeConfigs as mergeConfigs_alias_1 }
+export { mergeConfigs as mergeConfigs_alias_2 }
 
 declare const mongo: {
     getDateTime(now?: Date): string;
     createGenericFields({ returnDateAs, }?: {
         returnDateAs?: "string" | "date";
-    }): I_GenericDocument_2;
-    applyPlugins<T>(schema: T_MongooseShema_2<T>, plugins: Array<T_MongoosePlugin_2 | false>): void;
-    applyMiddlewares<T extends Partial<C_Document_2>>(schema: T_MongooseShema_2<T>, middlewares: I_MongooseModelMiddleware_2<T>[]): void;
-    createGenericSchema(mongoose: typeof mongooseRaw): mongooseRaw.Schema<I_GenericDocument_2, mongooseRaw.Model<I_GenericDocument_2, any, any, any, mongooseRaw.Document<unknown, any, I_GenericDocument_2> & I_GenericDocument_2 & Required<{
+    }): I_GenericDocument;
+    applyPlugins<T>(schema: T_MongooseShema<T>, plugins: Array<T_MongoosePlugin | false>): void;
+    applyMiddlewares<T extends Partial<C_Document>>(schema: T_MongooseShema<T>, middlewares: I_MongooseModelMiddleware<T>[]): void;
+    createGenericSchema(mongoose: typeof mongooseRaw): mongooseRaw.Schema<I_GenericDocument, mongooseRaw.Model<I_GenericDocument, any, any, any, mongooseRaw.Document<unknown, any, I_GenericDocument> & I_GenericDocument & Required<{
         _id: unknown;
     }> & {
         __v: number;
-    }, any>, {}, {}, {}, {}, mongooseRaw.DefaultSchemaOptions, I_GenericDocument_2, mongooseRaw.Document<unknown, {}, mongooseRaw.FlatRecord<I_GenericDocument_2>> & mongooseRaw.FlatRecord<I_GenericDocument_2> & Required<{
+    }, any>, {}, {}, {}, {}, mongooseRaw.DefaultSchemaOptions, I_GenericDocument, mongooseRaw.Document<unknown, {}, mongooseRaw.FlatRecord<I_GenericDocument>> & mongooseRaw.FlatRecord<I_GenericDocument> & Required<{
         _id: unknown;
     }> & {
         __v: number;
     }>;
-    createSchema<T extends Partial<C_Document_2>>({ mongoose, schema, virtuals, standalone, }: I_CreateSchemaOptions_2<T>): T_MongooseShema_2<T>;
-    createModel<T extends Partial<C_Document_2>>({ mongoose: currentMongooseInstance, name, schema, pagination, aggregate, virtuals, middlewares, }: I_CreateModelOptions_2<T>): I_ExtendedModel_2<T>;
-    createSlugQuery<T>(slug: string, filters?: T_FilterQuery_2<T>, id?: string): T_CreateSlugQueryResponse_2<T>;
+    createSchema<T extends Partial<C_Document>>({ mongoose, schema, virtuals, standalone, }: I_CreateSchemaOptions<T>): T_MongooseShema<T>;
+    createModel<T extends Partial<C_Document>>({ mongoose: currentMongooseInstance, name, schema, pagination, aggregate, virtuals, middlewares, }: I_CreateModelOptions<T>): I_ExtendedModel<T>;
+    createSlugQuery<T>(slug: string, filters?: T_FilterQuery<T>, id?: string): T_CreateSlugQueryResponse<T>;
     validator: {
         isEmpty<T>(): (this: T, value: unknown) => Promise<boolean>;
         isUnique<T extends {
@@ -2247,127 +2152,134 @@ declare const mongo: {
 export { mongo }
 export { mongo as mongo_alias_1 }
 export { mongo as mongo_alias_2 }
+export { mongo as mongo_alias_3 }
 
-declare class MongoController<D extends Partial<C_Document_2>> {
+declare class MongoController<D extends Partial<C_Document>> {
     private collection;
-    constructor(db: C_Db_2, collectionName: string);
+    constructor(db: C_Db, collectionName: string);
     createOne(document: D): Promise<{
         success: boolean;
         message: string;
-        result?: T_InsertOneResult_2<D>;
+        result?: T_InsertOneResult<D>;
     }>;
     createMany(documents: D[]): Promise<{
         success: boolean;
         message: string;
-        result?: T_InsertManyResult_2<D>;
+        result?: T_InsertManyResult<D>;
     }>;
-    findOne(filter: T_Filter_2<D>): Promise<{
+    findOne(filter: T_Filter<D>): Promise<{
         success: boolean;
         message: string;
-        result?: T_WithId_2<D> | null;
+        result?: T_WithId<D> | null;
     }>;
-    findAll(filter?: T_Filter_2<D>): Promise<{
+    findAll(filter?: T_Filter<D>): Promise<{
         success: boolean;
         message: string;
-        result?: T_WithId_2<D>[];
+        result?: T_WithId<D>[];
     }>;
-    count(filter?: T_Filter_2<D>): Promise<{
+    count(filter?: T_Filter<D>): Promise<{
         success: boolean;
         message: string;
         result?: number;
     }>;
-    updateOne(filter: T_Filter_2<D>, update: Partial<D>): Promise<{
+    updateOne(filter: T_Filter<D>, update: Partial<D>): Promise<{
         success: boolean;
         message: string;
-        result?: T_UpdateResult_2;
+        result?: T_UpdateResult;
     }>;
-    updateMany(filter: T_Filter_2<D>, update: Partial<D>): Promise<{
+    updateMany(filter: T_Filter<D>, update: Partial<D>): Promise<{
         success: boolean;
         message: string;
-        result?: T_UpdateResult_2;
+        result?: T_UpdateResult;
     }>;
-    deleteOne(filter: T_Filter_2<D>): Promise<{
+    deleteOne(filter: T_Filter<D>): Promise<{
         success: boolean;
         message: string;
-        result?: T_DeleteResult_2;
+        result?: T_DeleteResult;
     }>;
-    deleteMany(filter: T_Filter_2<D>): Promise<{
+    deleteMany(filter: T_Filter<D>): Promise<{
         success: boolean;
         message: string;
-        result?: T_DeleteResult_2;
+        result?: T_DeleteResult;
     }>;
 }
 export { MongoController }
 export { MongoController as MongoController_alias_1 }
 export { MongoController as MongoController_alias_2 }
+export { MongoController as MongoController_alias_3 }
 
-declare class MongooseController<T extends Partial<C_Document_2>> {
+declare class MongooseController<T extends Partial<C_Document>> {
     private model;
-    constructor(model: I_ExtendedModel_2<T>);
+    constructor(model: I_ExtendedModel<T>);
     private getModelName;
-    findOne(filter?: T_FilterQuery_2<T>, projection?: T_ProjectionType_2<T>, options?: T_QueryOptions_2<T>, populate?: T_Input_Populate_2): Promise<I_Return_2<T>>;
-    findAll(filter?: T_FilterQuery_2<T>, projection?: T_ProjectionType_2<T>, options?: T_QueryOptions_2<T>, populate?: T_Input_Populate_2): Promise<I_Return_2<T[]>>;
-    findPaging(filter?: T_FilterQuery_2<T>, options?: T_PaginateOptionsWithPopulate_2): Promise<I_Return_2<T_PaginateResult_2<T>>>;
-    findPagingAggregate(pipeline: T_PipelineStage_2[], options?: T_PaginateOptionsWithPopulate_2): Promise<I_Return_2<T_AggregatePaginateResult_2<T>>>;
-    count(filter?: T_FilterQuery_2<T>): Promise<I_Return_2<number>>;
-    createOne(doc: T | Partial<T>): Promise<I_Return_2<T>>;
-    createMany(docs: (T | Partial<T>)[], options?: T_InsertManyOptions_2): Promise<I_Return_2<T[]>>;
-    updateOne(filter?: T_FilterQuery_2<T>, update?: T_UpdateQuery_2<T>, options?: I_UpdateOptionsExtended_2): Promise<I_Return_2<T>>;
-    updateMany(filter?: T_FilterQuery_2<T>, update?: T_UpdateQuery_2<T>, options?: I_UpdateOptionsExtended_2): Promise<I_Return_2<T_UpdateResult_2>>;
-    deleteOne(filter?: T_FilterQuery_2<T>, options?: I_DeleteOptionsExtended_2): Promise<I_Return_2<T>>;
-    deleteMany(filter?: T_FilterQuery_2<T>, options?: I_DeleteOptionsExtended_2): Promise<I_Return_2<T_DeleteResult_2>>;
-    createShortId(id: string, length?: number): Promise<I_Return_2<string>>;
-    createSlug(fieldName: string, fields: T, filters?: T_FilterQuery_2<T>): Promise<I_Return_2<string | {
+    findOne(filter?: T_FilterQuery<T>, projection?: T_ProjectionType<T>, options?: T_QueryOptions<T>, populate?: T_Input_Populate): Promise<I_Return<T>>;
+    findAll(filter?: T_FilterQuery<T>, projection?: T_ProjectionType<T>, options?: T_QueryOptions<T>, populate?: T_Input_Populate): Promise<I_Return<T[]>>;
+    findPaging(filter?: T_FilterQuery<T>, options?: T_PaginateOptionsWithPopulate): Promise<I_Return<T_PaginateResult<T>>>;
+    findPagingAggregate(pipeline: T_PipelineStage[], options?: T_PaginateOptionsWithPopulate): Promise<I_Return<T_AggregatePaginateResult<T>>>;
+    count(filter?: T_FilterQuery<T>): Promise<I_Return<number>>;
+    createOne(doc: T | Partial<T>): Promise<I_Return<T>>;
+    createMany(docs: (T | Partial<T>)[], options?: T_InsertManyOptions): Promise<I_Return<T[]>>;
+    updateOne(filter?: T_FilterQuery<T>, update?: T_UpdateQuery<T>, options?: I_UpdateOptionsExtended): Promise<I_Return<T>>;
+    updateMany(filter?: T_FilterQuery<T>, update?: T_UpdateQuery<T>, options?: I_UpdateOptionsExtended): Promise<I_Return<T_UpdateResult>>;
+    deleteOne(filter?: T_FilterQuery<T>, options?: I_DeleteOptionsExtended): Promise<I_Return<T>>;
+    deleteMany(filter?: T_FilterQuery<T>, options?: I_DeleteOptionsExtended): Promise<I_Return<T_DeleteResult>>;
+    createShortId(id: string, length?: number): Promise<I_Return<string>>;
+    createSlug(fieldName: string, fields: T, filters?: T_FilterQuery<T>): Promise<I_Return<string | {
         [key: string]: string;
     }>>;
-    aggregate(pipeline: T_PipelineStage_2[]): Promise<I_Return_2<T[]>>;
+    aggregate(pipeline: T_PipelineStage[]): Promise<I_Return<T[]>>;
 }
 export { MongooseController }
 export { MongooseController as MongooseController_alias_1 }
 export { MongooseController as MongooseController_alias_2 }
+export { MongooseController as MongooseController_alias_3 }
 
 export { mongoosePaginate }
 export { mongoosePaginate as mongoosePaginate_alias_1 }
 export { mongoosePaginate as mongoosePaginate_alias_2 }
+export { mongoosePaginate as mongoosePaginate_alias_3 }
 
-declare const NextIntlContext: Context<I_NextIntlContextType_2 | undefined>;
+declare const NextIntlContext: Context<I_NextIntlContext | undefined>;
 export { NextIntlContext }
 export { NextIntlContext as NextIntlContext_alias_1 }
 export { NextIntlContext as NextIntlContext_alias_2 }
+export { NextIntlContext as NextIntlContext_alias_3 }
 
-declare function NextIntlProvider({ children, languages, messages, }: {
-    children: T_Children_2;
-    languages: I_NextIntlLanguage_2[];
-    messages: T_NextIntlMessageList_2;
-}): JSX_2.Element;
+declare function NextIntlProvider({ children, languages, messages, }: I_NextIntlProviderProps): JSX_2.Element;
 export { NextIntlProvider }
 export { NextIntlProvider as NextIntlProvider_alias_1 }
 export { NextIntlProvider as NextIntlProvider_alias_2 }
+export { NextIntlProvider as NextIntlProvider_alias_3 }
 
 declare const NODE_MODULES = "node_modules";
 export { NODE_MODULES }
 export { NODE_MODULES as NODE_MODULES_alias_1 }
 export { NODE_MODULES as NODE_MODULES_alias_2 }
+export { NODE_MODULES as NODE_MODULES_alias_3 }
 
 declare const NODE_MODULES_INSPECT_CLI = "node-modules-inspector";
 export { NODE_MODULES_INSPECT_CLI }
 export { NODE_MODULES_INSPECT_CLI as NODE_MODULES_INSPECT_CLI_alias_1 }
 export { NODE_MODULES_INSPECT_CLI as NODE_MODULES_INSPECT_CLI_alias_2 }
+export { NODE_MODULES_INSPECT_CLI as NODE_MODULES_INSPECT_CLI_alias_3 }
 
 declare const NODE_MODULES_INSPECT_PACKAGE_NAME = "node-modules-inspector";
 export { NODE_MODULES_INSPECT_PACKAGE_NAME }
 export { NODE_MODULES_INSPECT_PACKAGE_NAME as NODE_MODULES_INSPECT_PACKAGE_NAME_alias_1 }
 export { NODE_MODULES_INSPECT_PACKAGE_NAME as NODE_MODULES_INSPECT_PACKAGE_NAME_alias_2 }
+export { NODE_MODULES_INSPECT_PACKAGE_NAME as NODE_MODULES_INSPECT_PACKAGE_NAME_alias_3 }
 
 declare const PACKAGE_JSON = "package.json";
 export { PACKAGE_JSON }
 export { PACKAGE_JSON as PACKAGE_JSON_alias_1 }
 export { PACKAGE_JSON as PACKAGE_JSON_alias_2 }
+export { PACKAGE_JSON as PACKAGE_JSON_alias_3 }
 
 declare const PACKAGE_LOCK_JSON = "package-lock.json";
 export { PACKAGE_LOCK_JSON }
 export { PACKAGE_LOCK_JSON as PACKAGE_LOCK_JSON_alias_1 }
 export { PACKAGE_LOCK_JSON as PACKAGE_LOCK_JSON_alias_2 }
+export { PACKAGE_LOCK_JSON as PACKAGE_LOCK_JSON_alias_3 }
 
 declare function parseCommandOutput(output: string): void;
 
@@ -2394,26 +2306,31 @@ declare const PATH: {
 export { PATH }
 export { PATH as PATH_alias_1 }
 export { PATH as PATH_alias_2 }
+export { PATH as PATH_alias_3 }
 
 declare const PLAYWRIGHT_PACKAGE_NAME = "playwright";
 export { PLAYWRIGHT_PACKAGE_NAME }
 export { PLAYWRIGHT_PACKAGE_NAME as PLAYWRIGHT_PACKAGE_NAME_alias_1 }
 export { PLAYWRIGHT_PACKAGE_NAME as PLAYWRIGHT_PACKAGE_NAME_alias_2 }
+export { PLAYWRIGHT_PACKAGE_NAME as PLAYWRIGHT_PACKAGE_NAME_alias_3 }
 
 declare const PNPM_CLI = "pnpm";
 export { PNPM_CLI }
 export { PNPM_CLI as PNPM_CLI_alias_1 }
 export { PNPM_CLI as PNPM_CLI_alias_2 }
+export { PNPM_CLI as PNPM_CLI_alias_3 }
 
 declare const PNPM_EXEC_CLI = "pnpm exec";
 export { PNPM_EXEC_CLI }
 export { PNPM_EXEC_CLI as PNPM_EXEC_CLI_alias_1 }
 export { PNPM_EXEC_CLI as PNPM_EXEC_CLI_alias_2 }
+export { PNPM_EXEC_CLI as PNPM_EXEC_CLI_alias_3 }
 
 declare const PNPM_LOCK_YAML = "pnpm-lock.yaml";
 export { PNPM_LOCK_YAML }
 export { PNPM_LOCK_YAML as PNPM_LOCK_YAML_alias_1 }
 export { PNPM_LOCK_YAML as PNPM_LOCK_YAML_alias_2 }
+export { PNPM_LOCK_YAML as PNPM_LOCK_YAML_alias_3 }
 
 declare function rawCommand(cmd: string): {
     raw: boolean;
@@ -2422,6 +2339,7 @@ declare function rawCommand(cmd: string): {
 export { rawCommand }
 export { rawCommand as rawCommand_alias_1 }
 export { rawCommand as rawCommand_alias_2 }
+export { rawCommand as rawCommand_alias_3 }
 
 declare function readFileSync(filePath: string, options: {
     asJson: true;
@@ -2433,38 +2351,39 @@ declare function readFileSync(filePath: string, options?: {
 export { readFileSync }
 export { readFileSync as readFileSync_alias_1 }
 export { readFileSync as readFileSync_alias_2 }
+export { readFileSync as readFileSync_alias_3 }
 
 declare function regexSearchMapper(str: string): string;
 export { regexSearchMapper }
 export { regexSearchMapper as regexSearchMapper_alias_1 }
 export { regexSearchMapper as regexSearchMapper_alias_2 }
-
-declare function registerApolloErrorViewerCallback(fn: (err: ApolloError) => void): void;
-export { registerApolloErrorViewerCallback }
-export { registerApolloErrorViewerCallback as registerApolloErrorViewerCallback_alias_1 }
-export { registerApolloErrorViewerCallback as registerApolloErrorViewerCallback_alias_2 }
+export { regexSearchMapper as regexSearchMapper_alias_3 }
 
 declare function removeAccent(str: string): string;
 export { removeAccent }
 export { removeAccent as removeAccent_alias_1 }
 export { removeAccent as removeAccent_alias_2 }
+export { removeAccent as removeAccent_alias_3 }
 
 declare function resolve(...urls: string[]): string;
 export { resolve }
 export { resolve as resolve_alias_1 }
 export { resolve as resolve_alias_2 }
+export { resolve as resolve_alias_3 }
 
-declare function resolveCommands(input: T_CommandMapInput_2, context?: Partial<I_CommandContext_2>): Promise<{
-    [k: string]: string | I_Command_3;
+declare function resolveCommands(input: T_CommandMapInput, context?: Partial<I_CommandContext>): Promise<{
+    [k: string]: string | I_Command_2;
 }>;
 export { resolveCommands }
 export { resolveCommands as resolveCommands_alias_1 }
 export { resolveCommands as resolveCommands_alias_2 }
+export { resolveCommands as resolveCommands_alias_3 }
 
 declare function resolveWorkingPath(...urls: string[]): string;
 export { resolveWorkingPath }
 export { resolveWorkingPath as resolveWorkingPath_alias_1 }
 export { resolveWorkingPath as resolveWorkingPath_alias_2 }
+export { resolveWorkingPath as resolveWorkingPath_alias_3 }
 
 declare const RESPONSE_STATUS: {
     GRAPHQL_PARSE_FAILED: {
@@ -2724,59 +2643,66 @@ declare function rmSync(...paths: string[]): void;
 export { rmSync }
 export { rmSync as rmSync_alias_1 }
 export { rmSync as rmSync_alias_2 }
+export { rmSync as rmSync_alias_3 }
 
-declare const serializer: I_Serializer_2<unknown>;
+declare const serializer: I_Serializer<unknown>;
 export { serializer }
 export { serializer as serializer_alias_1 }
 export { serializer as serializer_alias_2 }
+export { serializer as serializer_alias_3 }
 
-declare function showGlobalApolloError(error: ApolloError): void;
+declare function showGlobalApolloError(error: ApolloError_2): void;
 export { showGlobalApolloError }
 export { showGlobalApolloError as showGlobalApolloError_alias_1 }
 export { showGlobalApolloError as showGlobalApolloError_alias_2 }
+export { showGlobalApolloError as showGlobalApolloError_alias_3 }
 
 declare const SIMPLE_GIT_HOOK_CLI = "simple-git-hooks";
 export { SIMPLE_GIT_HOOK_CLI }
 export { SIMPLE_GIT_HOOK_CLI as SIMPLE_GIT_HOOK_CLI_alias_1 }
 export { SIMPLE_GIT_HOOK_CLI as SIMPLE_GIT_HOOK_CLI_alias_2 }
+export { SIMPLE_GIT_HOOK_CLI as SIMPLE_GIT_HOOK_CLI_alias_3 }
 
 declare const SIMPLE_GIT_HOOK_JSON = ".simple-git-hooks.json";
 export { SIMPLE_GIT_HOOK_JSON }
 export { SIMPLE_GIT_HOOK_JSON as SIMPLE_GIT_HOOK_JSON_alias_1 }
 export { SIMPLE_GIT_HOOK_JSON as SIMPLE_GIT_HOOK_JSON_alias_2 }
+export { SIMPLE_GIT_HOOK_JSON as SIMPLE_GIT_HOOK_JSON_alias_3 }
 
 declare const SIMPLE_GIT_HOOKS_PACKAGE_NAME = "simple-git-hooks";
 export { SIMPLE_GIT_HOOKS_PACKAGE_NAME }
 export { SIMPLE_GIT_HOOKS_PACKAGE_NAME as SIMPLE_GIT_HOOKS_PACKAGE_NAME_alias_1 }
 export { SIMPLE_GIT_HOOKS_PACKAGE_NAME as SIMPLE_GIT_HOOKS_PACKAGE_NAME_alias_2 }
+export { SIMPLE_GIT_HOOKS_PACKAGE_NAME as SIMPLE_GIT_HOOKS_PACKAGE_NAME_alias_3 }
 
-declare const storageClient: {
+declare const storage: {
     get<T = unknown>(key: string): Promise<T | null>;
     set<T = unknown>(key: string, value: T): Promise<void>;
     remove(key: string): Promise<void>;
     keys(): Promise<string[]>;
 };
-export { storageClient }
-export { storageClient as storageClient_alias_1 }
-export { storageClient as storageClient_alias_2 }
+export { storage }
+export { storage as storage_alias_1 }
+export { storage as storage_alias_2 }
+export { storage as storage_alias_3 }
 
-declare const storageServer: {
+declare const storageNodeJS: {
     get<T = unknown>(key: string): Promise<T | null>;
     set<T = unknown>(key: string, value: T): Promise<void>;
     remove(key: string): Promise<void>;
     keys(): Promise<string[]>;
     getLogLink(key: string): Promise<string | null>;
 };
-export { storageServer }
-export { storageServer as storageServer_alias_1 }
-export { storageServer as storageServer_alias_2 }
+export { storageNodeJS }
+export { storageNodeJS as storageNodeJS_alias_1 }
+export { storageNodeJS as storageNodeJS_alias_2 }
+export { storageNodeJS as storageNodeJS_alias_3 }
 
 declare type T_AggregatePaginateResult<T> = AggregatePaginateResult<T>;
 export { T_AggregatePaginateResult }
 export { T_AggregatePaginateResult as T_AggregatePaginateResult_alias_1 }
 export { T_AggregatePaginateResult as T_AggregatePaginateResult_alias_2 }
-
-declare type T_AggregatePaginateResult_2<T> = AggregatePaginateResult<T>;
+export { T_AggregatePaginateResult as T_AggregatePaginateResult_alias_3 }
 
 declare type T_Children = ReactNode | ReactNode[] | ReactElement | JSX.Element | null;
 export { T_Children }
@@ -2789,34 +2715,27 @@ declare type T_Command = string | I_Command | T_CommandFunction;
 export { T_Command }
 export { T_Command as T_Command_alias_1 }
 export { T_Command as T_Command_alias_2 }
-
-declare type T_Command_2 =
-| string
-| I_Command_2
-| T_CommandFunction_2;
+export { T_Command as T_Command_alias_3 }
 
 declare type T_CommandFunction = (context?: I_CommandContext) => string;
 export { T_CommandFunction }
 export { T_CommandFunction as T_CommandFunction_alias_1 }
 export { T_CommandFunction as T_CommandFunction_alias_2 }
-
-declare type T_CommandFunction_2 = (context?: I_CommandContext_2) => string;
+export { T_CommandFunction as T_CommandFunction_alias_3 }
 
 declare type T_CommandMap = Record<string, T_Command>;
 export { T_CommandMap }
 export { T_CommandMap as T_CommandMap_alias_1 }
 export { T_CommandMap as T_CommandMap_alias_2 }
-
-declare type T_CommandMap_2 = Record<string, T_Command_2>;
+export { T_CommandMap as T_CommandMap_alias_3 }
 
 declare type T_CommandMapInput = T_CommandMap | ((ctx: I_CommandContext) => T_CommandMap);
 export { T_CommandMapInput }
 export { T_CommandMapInput as T_CommandMapInput_alias_1 }
 export { T_CommandMapInput as T_CommandMapInput_alias_2 }
+export { T_CommandMapInput as T_CommandMapInput_alias_3 }
 
-declare type T_CommandMapInput_2 = T_CommandMap_2 | ((ctx: I_CommandContext_2) => T_CommandMap_2);
-
-declare type T_ConfigHandler = (...configs: T_Object[]) => T_Object;
+declare type T_ConfigHandler = (...configs: T_Object_2[]) => T_Object_2;
 export { T_ConfigHandler }
 export { T_ConfigHandler as T_ConfigHandler_alias_1 }
 export { T_ConfigHandler as T_ConfigHandler_alias_2 }
@@ -2826,8 +2745,6 @@ export { T_ConfigType }
 export { T_ConfigType as T_ConfigType_alias_1 }
 export { T_ConfigType as T_ConfigType_alias_2 }
 
-declare type T_ConfigType_2 = `${E_ConfigType_2}`;
-
 declare type T_CreateSlugQueryResponse<T> = T_FilterQuery<T> & {
     $or: Array<{
         slug: string;
@@ -2842,127 +2759,109 @@ declare type T_CreateSlugQueryResponse<T> = T_FilterQuery<T> & {
 export { T_CreateSlugQueryResponse }
 export { T_CreateSlugQueryResponse as T_CreateSlugQueryResponse_alias_1 }
 export { T_CreateSlugQueryResponse as T_CreateSlugQueryResponse_alias_2 }
-
-declare type T_CreateSlugQueryResponse_2<T> = T_FilterQuery_2<T> & {
-    $or: Array<{ slug: string } | { slugHistory: string }>;
-} & { id?: { $ne: string } };
+export { T_CreateSlugQueryResponse as T_CreateSlugQueryResponse_alias_3 }
 
 declare type T_DeleteResult = DeleteResult;
 export { T_DeleteResult }
 export { T_DeleteResult as T_DeleteResult_alias_1 }
 export { T_DeleteResult as T_DeleteResult_alias_2 }
-
-declare type T_DeleteResult_2 = DeleteResult;
+export { T_DeleteResult as T_DeleteResult_alias_3 }
 
 declare type T_ErrorHandlingMiddlewareFunction<T> = ErrorHandlingMiddlewareFunction<T>;
 export { T_ErrorHandlingMiddlewareFunction }
 export { T_ErrorHandlingMiddlewareFunction as T_ErrorHandlingMiddlewareFunction_alias_1 }
 export { T_ErrorHandlingMiddlewareFunction as T_ErrorHandlingMiddlewareFunction_alias_2 }
-
-declare type T_ErrorHandlingMiddlewareFunction_2<T> = ErrorHandlingMiddlewareFunction<T>;
+export { T_ErrorHandlingMiddlewareFunction as T_ErrorHandlingMiddlewareFunction_alias_3 }
 
 declare type T_ErrorHandlingMiddlewareWithOption<T> = ErrorHandlingMiddlewareWithOption<T>;
 export { T_ErrorHandlingMiddlewareWithOption }
 export { T_ErrorHandlingMiddlewareWithOption as T_ErrorHandlingMiddlewareWithOption_alias_1 }
 export { T_ErrorHandlingMiddlewareWithOption as T_ErrorHandlingMiddlewareWithOption_alias_2 }
-
-declare type T_ErrorHandlingMiddlewareWithOption_2<T> = ErrorHandlingMiddlewareWithOption<T>;
+export { T_ErrorHandlingMiddlewareWithOption as T_ErrorHandlingMiddlewareWithOption_alias_3 }
 
 declare type T_Filter<T> = Filter<T>;
 export { T_Filter }
 export { T_Filter as T_Filter_alias_1 }
 export { T_Filter as T_Filter_alias_2 }
-
-declare type T_Filter_2<T> = Filter<T>;
+export { T_Filter as T_Filter_alias_3 }
 
 declare type T_FilterQuery<T> = FilterQuery<T>;
 export { T_FilterQuery }
 export { T_FilterQuery as T_FilterQuery_alias_1 }
 export { T_FilterQuery as T_FilterQuery_alias_2 }
-
-declare type T_FilterQuery_2<T> = FilterQuery<T>;
+export { T_FilterQuery as T_FilterQuery_alias_3 }
 
 declare type T_Input_MongooseSchema<T> = SchemaDefinition<T>;
 export { T_Input_MongooseSchema }
 export { T_Input_MongooseSchema as T_Input_MongooseSchema_alias_1 }
 export { T_Input_MongooseSchema as T_Input_MongooseSchema_alias_2 }
-
-declare type T_Input_MongooseSchema_2<T> = SchemaDefinition<T>;
+export { T_Input_MongooseSchema as T_Input_MongooseSchema_alias_3 }
 
 declare type T_Input_Populate = string | string[] | T_PopulateOptions | T_PopulateOptions[];
 export { T_Input_Populate }
 export { T_Input_Populate as T_Input_Populate_alias_1 }
 export { T_Input_Populate as T_Input_Populate_alias_2 }
-
-declare type T_Input_Populate_2 = string | string[] | T_PopulateOptions_2 | T_PopulateOptions_2[];
+export { T_Input_Populate as T_Input_Populate_alias_3 }
 
 declare type T_InsertManyOptions = InsertManyOptions;
 export { T_InsertManyOptions }
 export { T_InsertManyOptions as T_InsertManyOptions_alias_1 }
 export { T_InsertManyOptions as T_InsertManyOptions_alias_2 }
-
-declare type T_InsertManyOptions_2 = InsertManyOptions;
+export { T_InsertManyOptions as T_InsertManyOptions_alias_3 }
 
 declare type T_InsertManyResult<T> = InsertManyResult<T>;
 export { T_InsertManyResult }
 export { T_InsertManyResult as T_InsertManyResult_alias_1 }
 export { T_InsertManyResult as T_InsertManyResult_alias_2 }
-
-declare type T_InsertManyResult_2<T> = InsertManyResult<T>;
+export { T_InsertManyResult as T_InsertManyResult_alias_3 }
 
 declare type T_InsertOneResult<T> = InsertOneResult<T>;
 export { T_InsertOneResult }
 export { T_InsertOneResult as T_InsertOneResult_alias_1 }
 export { T_InsertOneResult as T_InsertOneResult_alias_2 }
-
-declare type T_InsertOneResult_2<T> = InsertOneResult<T>;
+export { T_InsertOneResult as T_InsertOneResult_alias_3 }
 
 declare type T_MongooseHookNextFunction = (error?: Error) => void;
 export { T_MongooseHookNextFunction }
 export { T_MongooseHookNextFunction as T_MongooseHookNextFunction_alias_1 }
 export { T_MongooseHookNextFunction as T_MongooseHookNextFunction_alias_2 }
+export { T_MongooseHookNextFunction as T_MongooseHookNextFunction_alias_3 }
 
 declare type T_MongooseMiddlewareMethod = string | RegExp;
 export { T_MongooseMiddlewareMethod }
 export { T_MongooseMiddlewareMethod as T_MongooseMiddlewareMethod_alias_1 }
 export { T_MongooseMiddlewareMethod as T_MongooseMiddlewareMethod_alias_2 }
-
-declare type T_MongooseMiddlewareMethod_2 = string | RegExp;
+export { T_MongooseMiddlewareMethod as T_MongooseMiddlewareMethod_alias_3 }
 
 declare type T_MongooseMiddlewarePostFunction<T> = T_PostMiddlewareFunction<T> & T_ErrorHandlingMiddlewareFunction<T> & T_ErrorHandlingMiddlewareWithOption<T>;
 export { T_MongooseMiddlewarePostFunction }
 export { T_MongooseMiddlewarePostFunction as T_MongooseMiddlewarePostFunction_alias_1 }
 export { T_MongooseMiddlewarePostFunction as T_MongooseMiddlewarePostFunction_alias_2 }
-
-declare type T_MongooseMiddlewarePostFunction_2<T> = T_PostMiddlewareFunction_2<T> & T_ErrorHandlingMiddlewareFunction_2<T> & T_ErrorHandlingMiddlewareWithOption_2<T>;
+export { T_MongooseMiddlewarePostFunction as T_MongooseMiddlewarePostFunction_alias_3 }
 
 declare type T_MongooseMiddlewarePreFunction<T> = T_PreMiddlewareFunction<T> & T_PreSaveMiddlewareFunction<T>;
 export { T_MongooseMiddlewarePreFunction }
 export { T_MongooseMiddlewarePreFunction as T_MongooseMiddlewarePreFunction_alias_1 }
 export { T_MongooseMiddlewarePreFunction as T_MongooseMiddlewarePreFunction_alias_2 }
-
-declare type T_MongooseMiddlewarePreFunction_2<T> = T_PreMiddlewareFunction_2<T> & T_PreSaveMiddlewareFunction_2<T>;
+export { T_MongooseMiddlewarePreFunction as T_MongooseMiddlewarePreFunction_alias_3 }
 
 declare type T_MongoosePlugin = (schema: Schema, options?: Record<string, unknown>) => void;
 export { T_MongoosePlugin }
 export { T_MongoosePlugin as T_MongoosePlugin_alias_1 }
 export { T_MongoosePlugin as T_MongoosePlugin_alias_2 }
-
-declare type T_MongoosePlugin_2 = (schema: Schema, options?: Record<string, unknown>) => void;
+export { T_MongoosePlugin as T_MongoosePlugin_alias_3 }
 
 declare type T_MongooseShema<T> = mongoose.Schema<T>;
 export { T_MongooseShema }
 export { T_MongooseShema as T_MongooseShema_alias_1 }
 export { T_MongooseShema as T_MongooseShema_alias_2 }
-
-declare type T_MongooseShema_2<T> = mongoose.Schema<T>;
+export { T_MongooseShema as T_MongooseShema_alias_3 }
 
 declare type T_NextIntlMessageList = Record<string, AbstractIntlMessages>;
 export { T_NextIntlMessageList }
 export { T_NextIntlMessageList as T_NextIntlMessageList_alias_1 }
 export { T_NextIntlMessageList as T_NextIntlMessageList_alias_2 }
-
-declare type T_NextIntlMessageList_2 = Record<string, AbstractIntlMessages>;
+export { T_NextIntlMessageList as T_NextIntlMessageList_alias_3 }
 
 declare type T_Object = Record<string, any>;
 export { T_Object }
@@ -2975,6 +2874,7 @@ declare type T_OptionalUnlessRequiredId<T> = OptionalUnlessRequiredId<T>;
 export { T_OptionalUnlessRequiredId }
 export { T_OptionalUnlessRequiredId as T_OptionalUnlessRequiredId_alias_1 }
 export { T_OptionalUnlessRequiredId as T_OptionalUnlessRequiredId_alias_2 }
+export { T_OptionalUnlessRequiredId as T_OptionalUnlessRequiredId_alias_3 }
 
 declare interface T_PackageJson {
     name?: string;
@@ -2986,101 +2886,80 @@ declare interface T_PackageJson {
 export { T_PackageJson }
 export { T_PackageJson as T_PackageJson_alias_1 }
 export { T_PackageJson as T_PackageJson_alias_2 }
-
-declare interface T_PackageJson_2 {
-    name?: string;
-    version?: string;
-    dependencies?: Record<string, string>;
-    devDependencies?: Record<string, string>;
-    [key: string]: any;
-}
+export { T_PackageJson as T_PackageJson_alias_3 }
 
 declare type T_PaginateOptions = PaginateOptions;
 export { T_PaginateOptions }
 export { T_PaginateOptions as T_PaginateOptions_alias_1 }
 export { T_PaginateOptions as T_PaginateOptions_alias_2 }
-
-declare type T_PaginateOptions_2 = PaginateOptions;
+export { T_PaginateOptions as T_PaginateOptions_alias_3 }
 
 declare interface T_PaginateOptionsWithPopulate extends T_PaginateOptions, T_PopulateOption {
 }
 export { T_PaginateOptionsWithPopulate }
 export { T_PaginateOptionsWithPopulate as T_PaginateOptionsWithPopulate_alias_1 }
 export { T_PaginateOptionsWithPopulate as T_PaginateOptionsWithPopulate_alias_2 }
-
-declare interface T_PaginateOptionsWithPopulate_2
-extends T_PaginateOptions_2,
-T_PopulateOption_2 { }
+export { T_PaginateOptionsWithPopulate as T_PaginateOptionsWithPopulate_alias_3 }
 
 declare type T_PaginateResult<T> = PaginateResult<T>;
 export { T_PaginateResult }
 export { T_PaginateResult as T_PaginateResult_alias_1 }
 export { T_PaginateResult as T_PaginateResult_alias_2 }
-
-declare type T_PaginateResult_2<T> = PaginateResult<T>;
+export { T_PaginateResult as T_PaginateResult_alias_3 }
 
 declare type T_PipelineStage = PipelineStage;
 export { T_PipelineStage }
 export { T_PipelineStage as T_PipelineStage_alias_1 }
 export { T_PipelineStage as T_PipelineStage_alias_2 }
-
-declare type T_PipelineStage_2 = PipelineStage;
+export { T_PipelineStage as T_PipelineStage_alias_3 }
 
 declare type T_PopulateOption = PopulateOption;
 export { T_PopulateOption }
 export { T_PopulateOption as T_PopulateOption_alias_1 }
 export { T_PopulateOption as T_PopulateOption_alias_2 }
-
-declare type T_PopulateOption_2 = PopulateOption;
+export { T_PopulateOption as T_PopulateOption_alias_3 }
 
 declare type T_PopulateOptions = PopulateOptions;
 export { T_PopulateOptions }
 export { T_PopulateOptions as T_PopulateOptions_alias_1 }
 export { T_PopulateOptions as T_PopulateOptions_alias_2 }
-
-declare type T_PopulateOptions_2 = PopulateOptions;
+export { T_PopulateOptions as T_PopulateOptions_alias_3 }
 
 declare type T_PostMiddlewareFunction<T> = PostMiddlewareFunction<T>;
 export { T_PostMiddlewareFunction }
 export { T_PostMiddlewareFunction as T_PostMiddlewareFunction_alias_1 }
 export { T_PostMiddlewareFunction as T_PostMiddlewareFunction_alias_2 }
-
-declare type T_PostMiddlewareFunction_2<T> = PostMiddlewareFunction<T>;
+export { T_PostMiddlewareFunction as T_PostMiddlewareFunction_alias_3 }
 
 declare type T_PreMiddlewareFunction<T> = PreMiddlewareFunction<T>;
 export { T_PreMiddlewareFunction }
 export { T_PreMiddlewareFunction as T_PreMiddlewareFunction_alias_1 }
 export { T_PreMiddlewareFunction as T_PreMiddlewareFunction_alias_2 }
-
-declare type T_PreMiddlewareFunction_2<T> = PreMiddlewareFunction<T>;
+export { T_PreMiddlewareFunction as T_PreMiddlewareFunction_alias_3 }
 
 declare type T_PreSaveMiddlewareFunction<T> = PreSaveMiddlewareFunction<T>;
 export { T_PreSaveMiddlewareFunction }
 export { T_PreSaveMiddlewareFunction as T_PreSaveMiddlewareFunction_alias_1 }
 export { T_PreSaveMiddlewareFunction as T_PreSaveMiddlewareFunction_alias_2 }
-
-declare type T_PreSaveMiddlewareFunction_2<T> = PreSaveMiddlewareFunction<T>;
+export { T_PreSaveMiddlewareFunction as T_PreSaveMiddlewareFunction_alias_3 }
 
 declare type T_ProjectionType<T> = ProjectionType<T>;
 export { T_ProjectionType }
 export { T_ProjectionType as T_ProjectionType_alias_1 }
 export { T_ProjectionType as T_ProjectionType_alias_2 }
-
-declare type T_ProjectionType_2<T> = ProjectionType<T>;
+export { T_ProjectionType as T_ProjectionType_alias_3 }
 
 declare type T_QueryOptions<T> = QueryOptions<T>;
 export { T_QueryOptions }
 export { T_QueryOptions as T_QueryOptions_alias_1 }
 export { T_QueryOptions as T_QueryOptions_alias_2 }
-
-declare type T_QueryOptions_2<T> = QueryOptions<T>;
+export { T_QueryOptions as T_QueryOptions_alias_3 }
 
 declare type T_QueryWithHelpers<T> = QueryWithHelpers<T, T>;
 export { T_QueryWithHelpers }
 export { T_QueryWithHelpers as T_QueryWithHelpers_alias_1 }
 export { T_QueryWithHelpers as T_QueryWithHelpers_alias_2 }
-
-declare type T_QueryWithHelpers_2<T> = QueryWithHelpers<T, T>;
+export { T_QueryWithHelpers as T_QueryWithHelpers_alias_3 }
 
 declare interface T_ThrowError {
     message?: string;
@@ -3093,41 +2972,31 @@ declare interface T_ThrowError {
 export { T_ThrowError }
 export { T_ThrowError as T_ThrowError_alias_1 }
 export { T_ThrowError as T_ThrowError_alias_2 }
-
-declare interface T_ThrowError_2 {
-    message?: string;
-    status?: {
-        CODE: string | number;
-        MESSAGE: string;
-    };
-    type?: 'graphql' | 'rest';
-}
+export { T_ThrowError as T_ThrowError_alias_3 }
 
 declare type T_UpdateQuery<T> = UpdateQuery<T>;
 export { T_UpdateQuery }
 export { T_UpdateQuery as T_UpdateQuery_alias_1 }
 export { T_UpdateQuery as T_UpdateQuery_alias_2 }
-
-declare type T_UpdateQuery_2<T> = UpdateQuery<T>;
+export { T_UpdateQuery as T_UpdateQuery_alias_3 }
 
 declare type T_UpdateResult = UpdateResult;
 export { T_UpdateResult }
 export { T_UpdateResult as T_UpdateResult_alias_1 }
 export { T_UpdateResult as T_UpdateResult_alias_2 }
-
-declare type T_UpdateResult_2 = UpdateResult;
+export { T_UpdateResult as T_UpdateResult_alias_3 }
 
 declare type T_WithId<T> = WithId<T>;
 export { T_WithId }
 export { T_WithId as T_WithId_alias_1 }
 export { T_WithId as T_WithId_alias_2 }
+export { T_WithId as T_WithId_alias_3 }
 
-declare type T_WithId_2<T> = WithId<T>;
-
-declare function throwError({ message, status, type, }: T_ThrowError_2): never;
+declare function throwError({ message, status, type, }: T_ThrowError): never;
 export { throwError }
 export { throwError as throwError_alias_1 }
 export { throwError as throwError_alias_2 }
+export { throwError as throwError_alias_3 }
 
 export { toast }
 export { toast as toast_alias_1 }
@@ -3141,36 +3010,43 @@ declare const TSC_CLI = "tsc";
 export { TSC_CLI }
 export { TSC_CLI as TSC_CLI_alias_1 }
 export { TSC_CLI as TSC_CLI_alias_2 }
+export { TSC_CLI as TSC_CLI_alias_3 }
 
 declare const TSC_PACKAGE_NAME = "typescript";
 export { TSC_PACKAGE_NAME }
 export { TSC_PACKAGE_NAME as TSC_PACKAGE_NAME_alias_1 }
 export { TSC_PACKAGE_NAME as TSC_PACKAGE_NAME_alias_2 }
+export { TSC_PACKAGE_NAME as TSC_PACKAGE_NAME_alias_3 }
 
 declare const TSCONFIG_JSON = "tsconfig.json";
 export { TSCONFIG_JSON }
 export { TSCONFIG_JSON as TSCONFIG_JSON_alias_1 }
 export { TSCONFIG_JSON as TSCONFIG_JSON_alias_2 }
+export { TSCONFIG_JSON as TSCONFIG_JSON_alias_3 }
 
 declare const TSX_CLI = "tsx";
 export { TSX_CLI }
 export { TSX_CLI as TSX_CLI_alias_1 }
 export { TSX_CLI as TSX_CLI_alias_2 }
+export { TSX_CLI as TSX_CLI_alias_3 }
 
-declare function useApolloErrorViewer(): I_ApolloErrorViewerContext_2;
-export { useApolloErrorViewer }
-export { useApolloErrorViewer as useApolloErrorViewer_alias_1 }
-export { useApolloErrorViewer as useApolloErrorViewer_alias_2 }
+declare function useApolloError(): I_ApolloErrorContext_2;
+export { useApolloError }
+export { useApolloError as useApolloError_alias_1 }
+export { useApolloError as useApolloError_alias_2 }
+export { useApolloError as useApolloError_alias_3 }
 
 declare function useLoading(): I_LoadingContext_2;
 export { useLoading }
 export { useLoading as useLoading_alias_1 }
 export { useLoading as useLoading_alias_2 }
+export { useLoading as useLoading_alias_3 }
 
-declare function useNextIntl(): I_NextIntlContextType_2;
+declare function useNextIntl(): I_NextIntlContext;
 export { useNextIntl }
 export { useNextIntl as useNextIntl_alias_1 }
 export { useNextIntl as useNextIntl_alias_2 }
+export { useNextIntl as useNextIntl_alias_3 }
 
 declare function useStorage<T>(key: string, initialValue?: T, serializer?: I_Serializer_2<T>): {
     value: T | undefined;
@@ -3180,11 +3056,13 @@ declare function useStorage<T>(key: string, initialValue?: T, serializer?: I_Ser
 export { useStorage }
 export { useStorage as useStorage_alias_1 }
 export { useStorage as useStorage_alias_2 }
+export { useStorage as useStorage_alias_3 }
 
 declare const useTranslateNextIntl: typeof useTranslations;
 export { useTranslateNextIntl }
 export { useTranslateNextIntl as useTranslateNextIntl_alias_1 }
 export { useTranslateNextIntl as useTranslateNextIntl_alias_2 }
+export { useTranslateNextIntl as useTranslateNextIntl_alias_3 }
 
 declare const validate: {
     isEmpty(value: unknown): boolean;
@@ -3192,34 +3070,49 @@ declare const validate: {
 export { validate }
 export { validate as validate_alias_1 }
 export { validate as validate_alias_2 }
+export { validate as validate_alias_3 }
 
 declare const VITEST_CLI = "vitest";
 export { VITEST_CLI }
 export { VITEST_CLI as VITEST_CLI_alias_1 }
 export { VITEST_CLI as VITEST_CLI_alias_2 }
+export { VITEST_CLI as VITEST_CLI_alias_3 }
 
 declare const VITEST_PACKAGE_NAME = "vitest";
 export { VITEST_PACKAGE_NAME }
 export { VITEST_PACKAGE_NAME as VITEST_PACKAGE_NAME_alias_1 }
 export { VITEST_PACKAGE_NAME as VITEST_PACKAGE_NAME_alias_2 }
+export { VITEST_PACKAGE_NAME as VITEST_PACKAGE_NAME_alias_3 }
 
-declare function withNextIntl<T extends {
-    children: T_Children_2;
-}>(Component: ComponentType<T>): {
+declare function vitestE2E(options: UserConfig): UserConfig;
+export { vitestE2E }
+export { vitestE2E as vitestE2E_alias_1 }
+export { vitestE2E as vitestE2E_alias_2 }
+export { vitestE2E as vitestE2E_alias_3 }
+
+declare function vitestUnit(options: UserConfig): UserConfig;
+export { vitestUnit }
+export { vitestUnit as vitestUnit_alias_1 }
+export { vitestUnit as vitestUnit_alias_2 }
+export { vitestUnit as vitestUnit_alias_3 }
+
+declare function withNextIntl<T extends I_Children_2>(Component: ComponentType<T>): {
     (props: T & {
-        languages: I_NextIntlLanguage_2[];
-        messages: T_NextIntlMessageList_2;
+        languages: I_NextIntlLanguage[];
+        messages: T_NextIntlMessageList;
     }): JSX_2.Element | null;
     displayName: string;
 };
 export { withNextIntl }
 export { withNextIntl as withNextIntl_alias_1 }
 export { withNextIntl as withNextIntl_alias_2 }
+export { withNextIntl as withNextIntl_alias_3 }
 
 declare const WORKING_DIRECTORY: string;
 export { WORKING_DIRECTORY }
 export { WORKING_DIRECTORY as WORKING_DIRECTORY_alias_1 }
 export { WORKING_DIRECTORY as WORKING_DIRECTORY_alias_2 }
+export { WORKING_DIRECTORY as WORKING_DIRECTORY_alias_3 }
 
 declare function writeFileSync(filePath: string, data: string | T_Object_2, options?: {
     isJson?: boolean;
@@ -3227,5 +3120,6 @@ declare function writeFileSync(filePath: string, data: string | T_Object_2, opti
 export { writeFileSync }
 export { writeFileSync as writeFileSync_alias_1 }
 export { writeFileSync as writeFileSync_alias_2 }
+export { writeFileSync as writeFileSync_alias_3 }
 
 export { }