cabloy 5.1.97 → 5.1.98

package/vona/src/suite/cabloy-basic/modules/basic-siteadmin/src/bean/ssrSite.admin.ts

@@ -22,5 +22,9 @@ export interface ISsrSiteOptionsAdmin extends IDecoratorSsrSiteOptions<
 @SsrSite<ISsrSiteOptionsAdmin>({
   publicPath: 'admin',
   bundlePath: 'ssr-cabloyBasicAdmin-5.0.0',
+  diagnostics: {
+    siteName: 'admin',
+    buildCommand: 'npm run build:zova:admin',
+  },
 })
 export class SsrSiteAdmin extends BeanSsrSiteBase<ISsrSiteOptionsAdmin> {}

package/vona/src/suite/cabloy-basic/modules/basic-siteweb/src/bean/ssrSite.web.ts

@@ -22,5 +22,9 @@ export interface ISsrSiteOptionsWeb extends IDecoratorSsrSiteOptions<
 @SsrSite<ISsrSiteOptionsWeb>({
   publicPath: '',
   bundlePath: 'ssr-cabloyBasicWeb-5.0.0',
+  diagnostics: {
+    siteName: 'web',
+    buildCommand: 'npm run build:zova:web',
+  },
 })
 export class SsrSiteWeb extends BeanSsrSiteBase<ISsrSiteOptionsWeb> {}

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/cli/ssrSite/boilerplate/{{sceneName}}.{{beanName}}.ts_

@@ -18,5 +18,8 @@ export interface ISsrSiteOptions<%=argv.beanNameCapitalize%> extends IDecoratorS
 @SsrSite<ISsrSiteOptions<%=argv.beanNameCapitalize%>>({
   publicPath: 'some',
   bundlePath: 'front-bundle-path',
+  diagnostics: {
+    siteName: 'some',
+  },
 })
 export class SsrSite<%=argv.beanNameCapitalize%> extends BeanSsrSiteBase<ISsrSiteOptions<%=argv.beanNameCapitalize%>> {}

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-ssr",
-  "version": "5.1.21",
+  "version": "5.1.24",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/src/service/ssrHandler.ts

@@ -51,8 +51,9 @@ export class ServiceSsrHandler extends BeanBase {
   private async _prepareHandler() {
     // handler
     const fileHandler = path.join(this._siteAssetDir, 'handler.js');
-    if (!fse.existsSync(fileHandler))
-      throw new Error(`The bundlePath of ssr site not exists: ${this._siteAssetDir}`);
+    if (!fse.existsSync(fileHandler)) {
+      throw new Error(this._createMissingBundleMessage());
+    }
     // import
     const fileUrl = `${pathToHref(fileHandler)}?${this._handlerNonce}`;
     const handlerInstance = await import(fileUrl);
@@ -65,4 +66,12 @@ export class ServiceSsrHandler extends BeanBase {
     // ok
     return ssrHandler;
   }
+
+  private _createMissingBundleMessage() {
+    const diagnostics = this._siteOptions.diagnostics;
+    const siteName = diagnostics?.siteName ?? String(this._siteOptions.publicPath || 'unknown');
+    const buildCommand = diagnostics?.buildCommand;
+    const commandHint = buildCommand ? ` Run "${buildCommand}" at the repository root.` : '';
+    return `Missing SSR bundle for site ${siteName}: ${this._siteAssetDir}.${commandHint}`;
+  }
 }

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/src/types/ssrSite.ts

@@ -50,6 +50,11 @@ export interface ISsrSitePublicPathRecord {}
 
 export interface ISsrSiteRecord {}
 
+export interface ISsrSiteDiagnosticsOptions {
+  siteName?: string;
+  buildCommand?: string;
+}
+
 export type TypeMergePagesAndPagesData<Pages extends {} = {}, PagesData extends {} = {}> = {
   // @ts-ignore: ignore
   [K in keyof Pages]: Pages[K] & { data?: PagesData[K] };
@@ -65,6 +70,7 @@ export interface IDecoratorSsrSiteOptions<
     IOnionOptionsMatch<TypeOnionOptionsMatchRule<keyof IInstanceRecord>> {
   publicPath: keyof ISsrSitePublicPathRecord;
   bundlePath: string;
+  diagnostics?: ISsrSiteDiagnosticsOptions;
   envServer?: ZovaConfigEnv;
   envClient?: ZovaConfigEnv;
   apiType: 'performAction' | 'api' | 'dev';

package/vona/src/suite-vendor/a-cabloy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-cabloy",
-  "version": "5.1.36",
+  "version": "5.1.39",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",

package/vona/src/suite-vendor/a-file/modules/a-file/cli/fileProvider/boilerplate/{{sceneName}}.{{beanName}}.ts_

@@ -0,0 +1,23 @@
+import type {
+  IDecoratorFileProviderOptions,
+  IFileProviderClientOptions,
+  IFileProviderClientRecord,
+  IFileProviderExecute,
+} from 'vona-module-a-file';
+
+import { BeanBase } from 'vona';
+import { FileProvider } from 'vona-module-a-file';
+
+export interface IFileProvider<%=argv.beanNameCapitalize%>ClientRecord extends IFileProviderClientRecord {}
+
+export interface IFileProvider<%=argv.beanNameCapitalize%>ClientOptions extends IFileProviderClientOptions {}
+
+export interface IFileProviderOptions<%=argv.beanNameCapitalize%> extends IDecoratorFileProviderOptions<
+  IFileProvider<%=argv.beanNameCapitalize%>ClientRecord,
+  IFileProvider<%=argv.beanNameCapitalize%>ClientOptions
+> {}
+
+@FileProvider<IFileProviderOptions<%=argv.beanNameCapitalize%>>({
+  base: {},
+})
+export class FileProvider<%=argv.beanNameCapitalize%> extends BeanBase implements IFileProviderExecute {}

package/vona/src/suite-vendor/a-file/modules/a-file/cli/fileScene/boilerplate/{{sceneName}}.{{beanName}}.ts_

@@ -0,0 +1,5 @@
+import { BeanBase } from 'vona';
+import { FileScene } from 'vona-module-a-file';
+
+@FileScene()
+export class FileScene<%=argv.beanNameCapitalize%> extends BeanBase {}

package/vona/src/suite-vendor/a-file/modules/a-file/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "vona-module-a-file",
+  "version": "5.0.3",
+  "description": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "author": "",
+  "files": [
+    "assets",
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/vona.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore"
+  },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "remove": [
+      "clean-package",
+      "devDependencies",
+      "exports.\\..import"
+    ]
+  },
+  "title": "a-file",
+  "vonaModule": {
+    "fileVersion": 1,
+    "dependencies": {
+      "a-orm": "5.0.0",
+      "a-upload": "5.0.0",
+      "a-user": "5.0.0",
+      "a-web": "5.0.0"
+    },
+    "onions": {
+      "fileProvider": {
+        "optionsGlobalInterfaceName": "IDecoratorFileProviderOptions",
+        "optionsGlobalInterfaceFrom": "vona-module-a-file",
+        "scopeResource": true
+      },
+      "fileScene": {
+        "optionsGlobalInterfaceName": "IDecoratorFileSceneOptions",
+        "optionsGlobalInterfaceFrom": "vona-module-a-file"
+      }
+    }
+  }
+}

package/vona/src/suite-vendor/a-file/modules/a-file/src/.metadata/index.ts

@@ -0,0 +1,425 @@
+// eslint-disable
+import type { TypeEntityMeta,TypeModelsClassLikeGeneral,TypeSymbolKeyFieldsMore } from 'vona-module-a-orm';
+import type { TypeEntityOptionsFields,TypeControllerOptionsActions } from 'vona-module-a-openapi';
+import type { TableIdentity } from 'table-identity';
+/** entity: begin */
+export * from '../entity/file.ts';
+export * from '../entity/fileProvider.ts';
+import type { IEntityOptionsFile } from '../entity/file.ts';
+import type { IEntityOptionsFileProvider } from '../entity/fileProvider.ts';
+import 'vona-module-a-orm';
+declare module 'vona-module-a-orm' {
+  
+    export interface IEntityRecord {
+      'a-file:file': IEntityOptionsFile;
+'a-file:fileProvider': IEntityOptionsFileProvider;
+    }
+
+  
+}
+declare module 'vona-module-a-file' {
+   
+}
+/** entity: end */
+/** entity: begin */
+import type { EntityFile } from '../entity/file.ts';
+import type { EntityFileProvider } from '../entity/fileProvider.ts';
+export interface IModuleEntity {
+  'file': EntityFileMeta;
+'fileProvider': EntityFileProviderMeta;
+}
+/** entity: end */
+/** entity: begin */
+export type EntityFileTableName = 'aFile';
+export type EntityFileProviderTableName = 'aFileProvider';
+export type EntityFileMeta=TypeEntityMeta<EntityFile,EntityFileTableName>;
+export type EntityFileProviderMeta=TypeEntityMeta<EntityFileProvider,EntityFileProviderTableName>;
+declare module 'vona-module-a-orm' {
+  export interface ITableRecord {
+    'aFile': EntityFileMeta;
+'aFileProvider': EntityFileProviderMeta;
+  }
+}
+declare module 'vona-module-a-file' {
+  
+    export interface IEntityOptionsFile {
+      fields?: TypeEntityOptionsFields<EntityFile, IEntityOptionsFile[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IEntityOptionsFileProvider {
+      fields?: TypeEntityOptionsFields<EntityFileProvider, IEntityOptionsFileProvider[TypeSymbolKeyFieldsMore]>;
+    }
+}
+/** entity: end */
+/** model: begin */
+export * from '../model/file.ts';
+export * from '../model/fileProvider.ts';
+import type { IModelOptionsFile } from '../model/file.ts';
+import type { IModelOptionsFileProvider } from '../model/fileProvider.ts';
+import 'vona-module-a-orm';
+declare module 'vona-module-a-orm' {
+  
+    export interface IModelRecord {
+      'a-file:file': IModelOptionsFile;
+'a-file:fileProvider': IModelOptionsFileProvider;
+    }
+
+  
+}
+declare module 'vona-module-a-file' {
+  
+        export interface ModelFile {
+          /** @internal */
+          get scope(): ScopeModuleAFile;
+        }
+
+          export interface ModelFile {
+            get $beanFullName(): 'a-file.model.file';
+            get $onionName(): 'a-file:file';
+            get $onionOptions(): IModelOptionsFile;
+          }
+
+        export interface ModelFileProvider {
+          /** @internal */
+          get scope(): ScopeModuleAFile;
+        }
+
+          export interface ModelFileProvider {
+            get $beanFullName(): 'a-file.model.fileProvider';
+            get $onionName(): 'a-file:fileProvider';
+            get $onionOptions(): IModelOptionsFileProvider;
+          } 
+}
+/** model: end */
+/** model: begin */
+import type { ModelFile } from '../model/file.ts';
+import type { ModelFileProvider } from '../model/fileProvider.ts';
+export interface IModuleModel {
+  'file': ModelFile;
+'fileProvider': ModelFileProvider;
+}
+/** model: end */
+/** model: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'a-file.model.file': ModelFile;
+'a-file.model.fileProvider': ModelFileProvider;
+  }
+}
+/** model: end */
+/** model: begin */
+import type { IModelGetOptions, IModelMethodOptions, IModelSelectParams, TypeModelSelectAndCount, TypeModelRelationResult, TypeModelWhere, IModelInsertOptions, TypeModelMutateRelationData, IModelDeleteOptions, IModelUpdateOptions, IModelMutateOptions, IModelSelectCountParams, IModelIncrementParams, IModelSelectAggrParams, TypeModelAggrRelationResult, IModelSelectGroupParams, TypeModelGroupRelationResult } from 'vona-module-a-orm';
+import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'vona-module-a-orm';
+declare module 'vona-module-a-file' {
+  
+  export interface ModelFile {
+      [SymbolKeyEntity]: EntityFile;
+      [SymbolKeyEntityMeta]: EntityFileMeta;
+      [SymbolKeyModelOptions]: IModelOptionsFile;
+      get<T extends IModelGetOptions<EntityFile,ModelFile>>(where: TypeModelWhere<EntityFile>, options?: T): Promise<TypeModelRelationResult<EntityFile, ModelFile, T> | undefined>;
+      mget<T extends IModelGetOptions<EntityFile,ModelFile>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityFile, ModelFile, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityFile,ModelFile,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityFile, ModelFile, T>>;
+      select<T extends IModelSelectParams<EntityFile,ModelFile,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityFile, ModelFile, T>[]>;
+      insert<T extends IModelInsertOptions<EntityFile,ModelFile>>(data?: TypeModelMutateRelationData<EntityFile,ModelFile, T>, options?: T): Promise<TypeModelMutateRelationData<EntityFile,ModelFile, T, true>>;
+      insertBulk<T extends IModelInsertOptions<EntityFile,ModelFile>>(items: TypeModelMutateRelationData<EntityFile,ModelFile, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityFile,ModelFile, T, true>[]>;
+      update<T extends IModelUpdateOptions<EntityFile,ModelFile>>(data: TypeModelMutateRelationData<EntityFile,ModelFile, T>, options?: T): Promise<TypeModelMutateRelationData<EntityFile,ModelFile, T>>;
+      updateBulk<T extends IModelUpdateOptions<EntityFile,ModelFile>>(items: TypeModelMutateRelationData<EntityFile,ModelFile, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityFile,ModelFile, T>[]>;
+      delete<T extends IModelDeleteOptions<EntityFile,ModelFile>>(where?: TypeModelWhere<EntityFile>, options?: T): Promise<void>;
+      deleteBulk<T extends IModelDeleteOptions<EntityFile,ModelFile>>(ids: TableIdentity[], options?: T): Promise<void>;
+      mutate<T extends IModelMutateOptions<EntityFile,ModelFile>>(data?: TypeModelMutateRelationData<EntityFile,ModelFile, T>, options?: T): Promise<TypeModelMutateRelationData<EntityFile,ModelFile, T>>;
+      mutateBulk<T extends IModelMutateOptions<EntityFile,ModelFile>>(items: TypeModelMutateRelationData<EntityFile,ModelFile, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityFile,ModelFile, T>[]>;
+      count<T extends IModelSelectCountParams<EntityFile,ModelFile,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<string | undefined>;
+      increment<T extends IModelIncrementParams<EntityFile,ModelFile,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      decrement<T extends IModelIncrementParams<EntityFile,ModelFile,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      aggregate<T extends IModelSelectAggrParams<EntityFile,ModelFile,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+      group<T extends IModelSelectGroupParams<EntityFile,ModelFile,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityFile, T>[]>;
+      getById<T extends IModelGetOptions<EntityFile,ModelFile>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityFile, ModelFile, T> | undefined>;
+updateById<T extends IModelUpdateOptions<EntityFile,ModelFile>>(id: TableIdentity, data: TypeModelMutateRelationData<EntityFile,ModelFile, T>, options?: T): Promise<TypeModelMutateRelationData<EntityFile,ModelFile, T>>;
+deleteById<T extends IModelDeleteOptions<EntityFile,ModelFile>>(id: TableIdentity, options?: T): Promise<void>;
+    }
+export interface ModelFileProvider {
+      [SymbolKeyEntity]: EntityFileProvider;
+      [SymbolKeyEntityMeta]: EntityFileProviderMeta;
+      [SymbolKeyModelOptions]: IModelOptionsFileProvider;
+      get<T extends IModelGetOptions<EntityFileProvider,ModelFileProvider>>(where: TypeModelWhere<EntityFileProvider>, options?: T): Promise<TypeModelRelationResult<EntityFileProvider, ModelFileProvider, T> | undefined>;
+      mget<T extends IModelGetOptions<EntityFileProvider,ModelFileProvider>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityFileProvider, ModelFileProvider, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityFileProvider,ModelFileProvider,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityFileProvider, ModelFileProvider, T>>;
+      select<T extends IModelSelectParams<EntityFileProvider,ModelFileProvider,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityFileProvider, ModelFileProvider, T>[]>;
+      insert<T extends IModelInsertOptions<EntityFileProvider,ModelFileProvider>>(data?: TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>, options?: T): Promise<TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T, true>>;
+      insertBulk<T extends IModelInsertOptions<EntityFileProvider,ModelFileProvider>>(items: TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T, true>[]>;
+      update<T extends IModelUpdateOptions<EntityFileProvider,ModelFileProvider>>(data: TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>, options?: T): Promise<TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>>;
+      updateBulk<T extends IModelUpdateOptions<EntityFileProvider,ModelFileProvider>>(items: TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>[]>;
+      delete<T extends IModelDeleteOptions<EntityFileProvider,ModelFileProvider>>(where?: TypeModelWhere<EntityFileProvider>, options?: T): Promise<void>;
+      deleteBulk<T extends IModelDeleteOptions<EntityFileProvider,ModelFileProvider>>(ids: TableIdentity[], options?: T): Promise<void>;
+      mutate<T extends IModelMutateOptions<EntityFileProvider,ModelFileProvider>>(data?: TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>, options?: T): Promise<TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>>;
+      mutateBulk<T extends IModelMutateOptions<EntityFileProvider,ModelFileProvider>>(items: TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>[]>;
+      count<T extends IModelSelectCountParams<EntityFileProvider,ModelFileProvider,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<string | undefined>;
+      increment<T extends IModelIncrementParams<EntityFileProvider,ModelFileProvider,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      decrement<T extends IModelIncrementParams<EntityFileProvider,ModelFileProvider,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      aggregate<T extends IModelSelectAggrParams<EntityFileProvider,ModelFileProvider,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+      group<T extends IModelSelectGroupParams<EntityFileProvider,ModelFileProvider,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityFileProvider, T>[]>;
+      getById<T extends IModelGetOptions<EntityFileProvider,ModelFileProvider>>(id: number, options?: T): Promise<TypeModelRelationResult<EntityFileProvider, ModelFileProvider, T> | undefined>;
+updateById<T extends IModelUpdateOptions<EntityFileProvider,ModelFileProvider>>(id: number, data: TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>, options?: T): Promise<TypeModelMutateRelationData<EntityFileProvider,ModelFileProvider, T>>;
+deleteById<T extends IModelDeleteOptions<EntityFileProvider,ModelFileProvider>>(id: number, options?: T): Promise<void>;
+getByDisabled<T extends IModelGetOptions<EntityFileProvider,ModelFileProvider>>(disabled?: boolean, options?: T): Promise<TypeModelRelationResult<EntityFileProvider, ModelFileProvider, T> | undefined>;
+selectByDisabled<T extends IModelSelectParams<EntityFileProvider,ModelFileProvider,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(disabled?: boolean, params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityFileProvider, ModelFileProvider, T>[]>;
+    }
+}
+declare module 'vona-module-a-orm' {
+  export interface IModelClassRecord {
+    'a-file:file': ModelFile;
+'a-file:fileProvider': ModelFileProvider;
+  }
+}
+/** model: end */
+/** bean: begin */
+export * from '../bean/bean.file.ts';
+export * from '../bean/bean.fileProvider.ts';
+export * from '../bean/bean.fileUploadPolicy.ts';
+
+import 'vona';
+declare module 'vona' {
+  
+  
+}
+declare module 'vona-module-a-file' {
+  
+        export interface BeanFile {
+          /** @internal */
+          get scope(): ScopeModuleAFile;
+        }
+
+        export interface BeanFileProvider {
+          /** @internal */
+          get scope(): ScopeModuleAFile;
+        }
+
+        export interface BeanFileUploadPolicy {
+          /** @internal */
+          get scope(): ScopeModuleAFile;
+        } 
+}
+/** bean: end */
+/** bean: begin */
+import type { BeanFile } from '../bean/bean.file.ts';
+import type { BeanFileProvider } from '../bean/bean.fileProvider.ts';
+import type { BeanFileUploadPolicy } from '../bean/bean.fileUploadPolicy.ts';
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGlobal {
+    'file': BeanFile;
+    'fileProvider': BeanFileProvider;
+    'fileUploadPolicy': BeanFileUploadPolicy;
+  }
+}
+/** bean: end */
+/** meta: begin */
+export * from '../bean/meta.redlock.ts';
+export * from '../bean/meta.version.ts';
+
+import 'vona-module-a-meta';
+declare module 'vona-module-a-meta' {
+  
+    export interface IMetaRecord {
+      'a-file:redlock': never;
+'a-file:version': never;
+    }
+
+  
+}
+declare module 'vona-module-a-file' {
+  
+        export interface MetaRedlock {
+          /** @internal */
+          get scope(): ScopeModuleAFile;
+        }
+
+          export interface MetaRedlock {
+            get $beanFullName(): 'a-file.meta.redlock';
+            get $onionName(): 'a-file:redlock';
+            
+          }
+
+        export interface MetaVersion {
+          /** @internal */
+          get scope(): ScopeModuleAFile;
+        }
+
+          export interface MetaVersion {
+            get $beanFullName(): 'a-file.meta.version';
+            get $onionName(): 'a-file:version';
+            
+          } 
+}
+/** meta: end */
+/** meta redlock: begin */
+import type { MetaRedlock } from '../bean/meta.redlock.ts';
+/** meta redlock: end */
+/** dto: begin */
+export * from '../dto/fileDirectUploadRequest.ts';
+export * from '../dto/fileDirectUploadResponse.ts';
+export * from '../dto/fileDownloadRequest.ts';
+export * from '../dto/fileUploadResponse.ts';
+export * from '../dto/fileUploadTokenRequest.ts';
+export * from '../dto/fileUploadTokenResponse.ts';
+export * from '../dto/fileUploadUrlRequest.ts';
+import type { IDtoOptionsFileDirectUploadRequest } from '../dto/fileDirectUploadRequest.ts';
+import type { IDtoOptionsFileDirectUploadResponse } from '../dto/fileDirectUploadResponse.ts';
+import type { IDtoOptionsFileDownloadRequest } from '../dto/fileDownloadRequest.ts';
+import type { IDtoOptionsFileUploadResponse } from '../dto/fileUploadResponse.ts';
+import type { IDtoOptionsFileUploadTokenRequest } from '../dto/fileUploadTokenRequest.ts';
+import type { IDtoOptionsFileUploadTokenResponse } from '../dto/fileUploadTokenResponse.ts';
+import type { IDtoOptionsFileUploadUrlRequest } from '../dto/fileUploadUrlRequest.ts';
+import 'vona-module-a-web';
+declare module 'vona-module-a-web' {
+  
+    export interface IDtoRecord {
+      'a-file:fileDirectUploadRequest': IDtoOptionsFileDirectUploadRequest;
+'a-file:fileDirectUploadResponse': IDtoOptionsFileDirectUploadResponse;
+'a-file:fileDownloadRequest': IDtoOptionsFileDownloadRequest;
+'a-file:fileUploadResponse': IDtoOptionsFileUploadResponse;
+'a-file:fileUploadTokenRequest': IDtoOptionsFileUploadTokenRequest;
+'a-file:fileUploadTokenResponse': IDtoOptionsFileUploadTokenResponse;
+'a-file:fileUploadUrlRequest': IDtoOptionsFileUploadUrlRequest;
+    }
+
+  
+}
+declare module 'vona-module-a-file' {
+   
+}
+/** dto: end */
+/** dto: begin */
+import type { DtoFileDirectUploadRequest } from '../dto/fileDirectUploadRequest.ts';
+import type { DtoFileDirectUploadResponse } from '../dto/fileDirectUploadResponse.ts';
+import type { DtoFileDownloadRequest } from '../dto/fileDownloadRequest.ts';
+import type { DtoFileUploadResponse } from '../dto/fileUploadResponse.ts';
+import type { DtoFileUploadTokenRequest } from '../dto/fileUploadTokenRequest.ts';
+import type { DtoFileUploadTokenResponse } from '../dto/fileUploadTokenResponse.ts';
+import type { DtoFileUploadUrlRequest } from '../dto/fileUploadUrlRequest.ts';
+declare module 'vona-module-a-file' {
+  
+    export interface IDtoOptionsFileDirectUploadRequest {
+      fields?: TypeEntityOptionsFields<DtoFileDirectUploadRequest, IDtoOptionsFileDirectUploadRequest[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsFileDirectUploadResponse {
+      fields?: TypeEntityOptionsFields<DtoFileDirectUploadResponse, IDtoOptionsFileDirectUploadResponse[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsFileDownloadRequest {
+      fields?: TypeEntityOptionsFields<DtoFileDownloadRequest, IDtoOptionsFileDownloadRequest[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsFileUploadResponse {
+      fields?: TypeEntityOptionsFields<DtoFileUploadResponse, IDtoOptionsFileUploadResponse[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsFileUploadTokenRequest {
+      fields?: TypeEntityOptionsFields<DtoFileUploadTokenRequest, IDtoOptionsFileUploadTokenRequest[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsFileUploadTokenResponse {
+      fields?: TypeEntityOptionsFields<DtoFileUploadTokenResponse, IDtoOptionsFileUploadTokenResponse[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsFileUploadUrlRequest {
+      fields?: TypeEntityOptionsFields<DtoFileUploadUrlRequest, IDtoOptionsFileUploadUrlRequest[TypeSymbolKeyFieldsMore]>;
+    }
+}
+/** dto: end */
+/** controller: begin */
+export * from '../controller/file.ts';
+import type { IControllerOptionsFile } from '../controller/file.ts';
+import 'vona-module-a-web';
+declare module 'vona-module-a-web' {
+  
+    export interface IControllerRecord {
+      'a-file:file': IControllerOptionsFile;
+    }
+
+  
+}
+declare module 'vona-module-a-file' {
+  
+        export interface ControllerFile {
+          /** @internal */
+          get scope(): ScopeModuleAFile;
+        }
+
+          export interface ControllerFile {
+            get $beanFullName(): 'a-file.controller.file';
+            get $onionName(): 'a-file:file';
+            get $onionOptions(): IControllerOptionsFile;
+          } 
+}
+/** controller: end */
+/** controller: begin */
+// @ts-ignore ignore
+import type { ControllerFile } from '../controller/file.ts';
+declare module 'vona-module-a-file' {
+  
+    export interface IControllerOptionsFile {
+      actions?: TypeControllerOptionsActions<ControllerFile>;
+    }
+}
+declare module 'vona-module-a-web' {
+  export interface IApiPathPostRecord{
+        '/file/upload-token': undefined;
+'/file/upload': undefined;
+'/file/direct-upload': undefined;
+'/file/upload-url': undefined;
+    }
+export interface IApiPathGetRecord{
+        '/file/download/:fileId': undefined;
+    }
+
+}
+
+/** controller: end */
+/** config: begin */
+export * from '../config/config.ts';
+import type { config } from '../config/config.ts';
+/** config: end */
+/** locale: begin */
+import { locales } from './locales.ts';
+/** locale: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig, type TypeModuleLocales, type TypeLocaleBase } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export class ScopeModuleAFile extends BeanScopeBase {}
+
+export interface ScopeModuleAFile {
+  util: BeanScopeUtil;
+config: TypeModuleConfig<typeof config>;
+locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
+entity: IModuleEntity;
+model: IModuleModel;
+redlock: MetaRedlock;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'a-file': ScopeModuleAFile;
+  }
+
+  export interface IBeanScopeContainer {
+    file: ScopeModuleAFile;
+  }
+  
+  export interface IBeanScopeConfig {
+    'a-file': ReturnType<typeof config>;
+  }
+
+  export interface IBeanScopeLocale {
+    'a-file': (typeof locales)[TypeLocaleBase];
+  }
+
+  
+}
+/** scope: end */

package/vona/src/suite-vendor/a-file/modules/a-file/src/.metadata/locales.ts

@@ -0,0 +1,18 @@
+import type { TypeLocaleBase } from 'vona';
+
+import { $makeLocaleMagic } from 'vona';
+
+import locale_en_us from '../config/locale/en-us.ts';
+import locale_zh_cn from '../config/locale/zh-cn.ts';
+
+export const locales = {
+  'en-us': locale_en_us,
+  'zh-cn': locale_zh_cn,
+};
+
+export function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(
+  key: K,
+  ...args: any[]
+): any {
+  return $makeLocaleMagic(`a-file::${key}`, ...args);
+}

package/vona/src/suite-vendor/a-file/modules/a-file/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'a-file';
+export { ScopeModuleAFile as ScopeModule } from './index.ts';