vona-module-test-vona 5.0.12 → 5.0.14

package/dist/.metadata/index.d.ts

@@ -0,0 +1,551 @@
+import type { BeanScopeUtil, TypeLocaleBase, TypeModuleConfig, TypeModuleLocales } from 'vona';
+import type { IDecoratorAopOptions } from 'vona-module-a-aspect';
+import type { IDecoratorBroadcastOptions } from 'vona-module-a-broadcast';
+import type { IDecoratorCacheMemOptions } from 'vona-module-a-cache';
+import type { IDecoratorCacheRedisOptions } from 'vona-module-a-cache';
+import type { IDecoratorModelOptions } from 'vona-module-a-database';
+import type { EventOn } from 'vona-module-a-event';
+import type { IDecoratorEventListenerOptions } from 'vona-module-a-event';
+import type { TypeControllerOptionsActions } from 'vona-module-a-openapi';
+import type { TypeEntityOptionsFields } from 'vona-module-a-openapi';
+import type { IDecoratorQueueOptions } from 'vona-module-a-queue';
+import type { IDecoratorScheduleOptions } from 'vona-module-a-schedule';
+import type { IDecoratorSummerCacheOptions } from 'vona-module-a-summer';
+import type { IAopMethodOptionsTest } from '../bean/aopMethod.test.ts';
+/** bean: end */
+/** bean: begin */
+import type { BeanTestCtx } from '../bean/bean.testCtx.ts';
+/** broadcast: end */
+/** broadcast: begin */
+import type { BroadcastTest } from '../bean/broadcast.test.ts';
+/** cacheMem: end */
+/** cacheMem: begin */
+import type { CacheMemTest } from '../bean/cacheMem.test.ts';
+/** cacheRedis: end */
+/** cacheRedis: begin */
+import type { CacheRedisTest } from '../bean/cacheRedis.test.ts';
+/** event: end */
+/** event: begin */
+import type { EventHelloEcho } from '../bean/event.helloEcho.ts';
+/** event: end */
+/** event: begin */
+import type { TypeEventHelloEchoData, TypeEventHelloEchoResult } from '../bean/event.helloEcho.ts';
+/** queue: end */
+/** queue: begin */
+import type { QueueTest } from '../bean/queue.test.ts';
+/** summerCache: end */
+/** summerCache: begin */
+import type { SummerCacheTest } from '../bean/summerCache.test.ts';
+import type { config } from '../config/config.ts';
+import type { IControllerOptionsBean } from '../controller/bean.ts';
+/** controller: end */
+/** controller: begin */
+import '../controller/bean.ts';
+import type { IControllerOptionsCacheMem } from '../controller/cacheMem.ts';
+import '../controller/cacheMem.ts';
+import type { IControllerOptionsCacheRedis } from '../controller/cacheRedis.ts';
+import '../controller/cacheRedis.ts';
+import type { IControllerOptionsOnion } from '../controller/onion.ts';
+import '../controller/onion.ts';
+import type { IControllerOptionsPassport } from '../controller/passport.ts';
+import '../controller/passport.ts';
+import type { IControllerOptionsPerformAction } from '../controller/performAction.ts';
+import '../controller/performAction.ts';
+import type { IControllerOptionsQueue } from '../controller/queue.ts';
+import '../controller/queue.ts';
+import type { IControllerOptionsSummer } from '../controller/summer.ts';
+import '../controller/summer.ts';
+import type { IControllerOptionsTail } from '../controller/tail.ts';
+import '../controller/tail.ts';
+/** service: end */
+/** service: begin */
+import type { IControllerOptionsTransaction } from '../controller/transaction.ts';
+import '../controller/transaction.ts';
+import type { IControllerOptionsUpload } from '../controller/upload.ts';
+import '../controller/upload.ts';
+import type { IDtoOptionsProfile } from '../dto/profile.ts';
+/** dto: end */
+/** dto: begin */
+import type { DtoProfile } from '../dto/profile.ts';
+import type { IDtoOptionsUser } from '../dto/user.ts';
+import type { DtoUser } from '../dto/user.ts';
+import type { IEntityOptionsTest } from '../entity/test.ts';
+/** entity: end */
+/** entity: begin */
+import type { EntityTest } from '../entity/test.ts';
+/** model: end */
+/** model: begin */
+import type { ModelTest } from '../model/test.ts';
+/** service: end */
+/** service: begin */
+import type { ServiceAopMethod } from '../service/aopMethod.ts';
+import type { ServiceTest } from '../service/test.ts';
+import type { ServiceTestApp } from '../service/testApp.ts';
+import type { ServiceTestClass } from '../service/testClass.ts';
+import type { ServiceTransaction } from '../service/transaction.ts';
+/** locale: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+/** aop: begin */
+export * from '../bean/aop.regExp.ts';
+export * from '../bean/aop.simple.ts';
+declare module 'vona-module-a-aspect' {
+    interface IAopRecord {
+        'test-vona:regExp': IDecoratorAopOptions;
+        'test-vona:simple': IDecoratorAopOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface AopRegExp {
+    }
+    interface AopSimple {
+    }
+}
+/** aop: end */
+/** aopMethod: begin */
+export * from '../bean/aopMethod.test.ts';
+declare module 'vona-module-a-aspect' {
+    interface IAopMethodRecord {
+        'test-vona:test': IAopMethodOptionsTest;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface AopMethodTest {
+    }
+}
+/** model: end */
+/** bean: begin */
+export * from '../bean/bean.testCtx.ts';
+declare module 'vona-module-a-database' {
+    interface IEntityRecord {
+        'test-vona:test': IEntityOptionsTest;
+    }
+}
+declare module 'vona-module-test-vona' {
+}
+export interface IModuleEntity {
+    test: EntityTest;
+}
+/** entity: end */
+/** entity: begin */
+declare module 'vona-module-test-vona' {
+    interface EntityTest {
+        $column: <K extends keyof Omit<EntityTest, '$column' | '$columns' | '$table'>>(column: K) => K;
+        $columns: <K extends keyof Omit<EntityTest, '$column' | '$columns' | '$table'>>(...columns: K[]) => K[];
+    }
+    interface IEntityOptionsTest {
+        fields?: TypeEntityOptionsFields<EntityTest, IEntityOptionsTest['fieldsMore']>;
+    }
+}
+/** bean: end */
+/** broadcast: begin */
+export * from '../bean/broadcast.test.ts';
+declare module 'vona-module-a-database' {
+    interface IModelRecord {
+        'test-vona:test': IDecoratorModelOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface ModelTest {
+    }
+}
+export interface IModuleModel {
+    test: ModelTest;
+}
+/** broadcast: end */
+/** cacheMem: begin */
+export * from '../bean/cacheMem.test.ts';
+declare module 'vona' {
+}
+declare module 'vona-module-test-vona' {
+    interface BeanTestCtx {
+    }
+}
+declare module 'vona' {
+    interface IBeanRecordGlobal {
+        testCtx: BeanTestCtx;
+    }
+}
+/** cacheMem: end */
+/** cacheRedis: begin */
+export * from '../bean/cacheRedis.test.ts';
+declare module 'vona-module-a-broadcast' {
+    interface IBroadcastRecord {
+        'test-vona:test': IDecoratorBroadcastOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface BroadcastTest {
+    }
+}
+export interface IModuleBroadcast {
+    test: BroadcastTest;
+}
+/** cacheRedis: end */
+/** event: begin */
+export * from '../bean/event.helloEcho.ts';
+declare module 'vona-module-a-cache' {
+    interface ICacheMemRecord {
+        'test-vona:test': IDecoratorCacheMemOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface CacheMemTest {
+    }
+}
+export interface IModuleCacheMem {
+    test: CacheMemTest;
+}
+/** event: end */
+/** eventListener: begin */
+export * from '../bean/eventListener.helloEcho.ts';
+declare module 'vona-module-a-cache' {
+    interface ICacheRedisRecord {
+        'test-vona:test': IDecoratorCacheRedisOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface CacheRedisTest {
+    }
+}
+export interface IModuleCacheRedis {
+    test: CacheRedisTest;
+}
+/** eventListener: end */
+/** meta: begin */
+export * from '../bean/meta.version.ts';
+declare module 'vona' {
+}
+declare module 'vona-module-test-vona' {
+    interface EventHelloEcho {
+    }
+}
+export interface IModuleEvent {
+    helloEcho: EventHelloEcho;
+}
+declare module 'vona-module-a-event' {
+    interface IEventRecord {
+        'test-vona:helloEcho': EventOn<TypeEventHelloEchoData, TypeEventHelloEchoResult>;
+    }
+}
+/** meta: end */
+/** queue: begin */
+export * from '../bean/queue.test.ts';
+declare module 'vona-module-a-event' {
+    interface IEventListenerRecord {
+        'test-vona:helloEcho': IDecoratorEventListenerOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface EventListenerHelloEcho {
+    }
+}
+export * from '../bean/schedule.test3.ts';
+declare module 'vona' {
+    interface IMetaRecord {
+        'test-vona:version': never;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface MetaVersion {
+    }
+}
+/** queue: end */
+/** schedule: begin */
+export * from '../bean/schedule.test.ts';
+declare module 'vona-module-a-queue' {
+    interface IQueueRecord {
+        'test-vona:test': IDecoratorQueueOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface QueueTest {
+    }
+}
+export interface IModuleQueue {
+    test: QueueTest;
+}
+/** schedule: end */
+/** summerCache: begin */
+export * from '../bean/summerCache.test.ts';
+/** controller: end */
+/** config: begin */
+export * from '../config/config.ts';
+declare module 'vona-module-a-schedule' {
+    interface IScheduleRecord {
+        'test-vona:test': IDecoratorScheduleOptions;
+        'test-vona:test3': IDecoratorScheduleOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface ScheduleTest {
+    }
+    interface ScheduleTest3 {
+    }
+}
+/** service: end */
+/** controller: begin */
+export * from '../controller/bean.ts';
+declare module 'vona-module-a-summer' {
+    interface ISummerCacheRecord {
+        'test-vona:test': IDecoratorSummerCacheOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface SummerCacheTest {
+    }
+}
+export interface IModuleSummerCache {
+    test: SummerCacheTest;
+}
+export * from '../controller/cacheMem.ts';
+export * from '../controller/cacheRedis.ts';
+declare module 'vona-module-a-web' {
+    interface IDtoRecord {
+        'test-vona:profile': IDtoOptionsProfile;
+        'test-vona:user': IDtoOptionsUser;
+    }
+}
+declare module 'vona-module-test-vona' {
+}
+declare module 'vona-module-test-vona' {
+    interface IDtoOptionsProfile {
+        fields?: TypeEntityOptionsFields<DtoProfile, IDtoOptionsProfile['fieldsMore']>;
+    }
+    interface IDtoOptionsUser {
+        fields?: TypeEntityOptionsFields<DtoUser, IDtoOptionsUser['fieldsMore']>;
+    }
+}
+export * from '../controller/onion.ts';
+export * from '../controller/passport.ts';
+export * from '../controller/performAction.ts';
+export * from '../controller/queue.ts';
+export * from '../controller/summer.ts';
+declare module 'vona-module-a-web' {
+    interface IServiceRecord {
+        'test-vona:aopMethod': never;
+        'test-vona:test': never;
+        'test-vona:testApp': never;
+        'test-vona:testClass': never;
+        'test-vona:transaction': never;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface ServiceAopMethod {
+    }
+    interface ServiceTest {
+    }
+    interface ServiceTestApp {
+    }
+    interface ServiceTestClass {
+    }
+    interface ServiceTransaction {
+    }
+}
+export interface IModuleService {
+    aopMethod: ServiceAopMethod;
+    test: ServiceTest;
+    testApp: ServiceTestApp;
+    testClass: ServiceTestClass;
+    transaction: ServiceTransaction;
+}
+declare module 'vona' {
+    interface IBeanRecordGeneral {
+        'test-vona.service.aopMethod': ServiceAopMethod;
+        'test-vona.service.test': ServiceTest;
+        'test-vona.service.testApp': ServiceTestApp;
+        'test-vona.service.testClass': ServiceTestClass;
+        'test-vona.service.transaction': ServiceTransaction;
+    }
+}
+export * from '../controller/tail.ts';
+export * from '../controller/transaction.ts';
+export * from '../controller/upload.ts';
+/** summerCache: end */
+/** dto: begin */
+export * from '../dto/profile.ts';
+export * from '../dto/user.ts';
+/** aopMethod: end */
+/** entity: begin */
+export * from '../entity/test.ts';
+/** entity: end */
+/** model: begin */
+export * from '../model/test.ts';
+/** dto: end */
+/** service: begin */
+export * from '../service/aopMethod.ts';
+export * from '../service/test.ts';
+export * from '../service/testApp.ts';
+export * from '../service/testClass.ts';
+declare module 'vona-module-a-web' {
+    interface IControllerRecord {
+        'test-vona:bean': IControllerOptionsBean;
+        'test-vona:cacheMem': IControllerOptionsCacheMem;
+        'test-vona:cacheRedis': IControllerOptionsCacheRedis;
+        'test-vona:onion': IControllerOptionsOnion;
+        'test-vona:passport': IControllerOptionsPassport;
+        'test-vona:performAction': IControllerOptionsPerformAction;
+        'test-vona:queue': IControllerOptionsQueue;
+        'test-vona:summer': IControllerOptionsSummer;
+        'test-vona:tail': IControllerOptionsTail;
+        'test-vona:transaction': IControllerOptionsTransaction;
+        'test-vona:upload': IControllerOptionsUpload;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface ControllerBean {
+    }
+    interface ControllerCacheMem {
+    }
+    interface ControllerCacheRedis {
+    }
+    interface ControllerOnion {
+    }
+    interface ControllerPassport {
+    }
+    interface ControllerPerformAction {
+    }
+    interface ControllerQueue {
+    }
+    interface ControllerSummer {
+    }
+    interface ControllerTail {
+    }
+    interface ControllerTransaction {
+    }
+    interface ControllerUpload {
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface IControllerOptionsBean {
+        actions?: TypeControllerOptionsActions<ControllerBean>;
+    }
+    interface IControllerOptionsCacheMem {
+        actions?: TypeControllerOptionsActions<ControllerCacheMem>;
+    }
+    interface IControllerOptionsCacheRedis {
+        actions?: TypeControllerOptionsActions<ControllerCacheRedis>;
+    }
+    interface IControllerOptionsOnion {
+        actions?: TypeControllerOptionsActions<ControllerOnion>;
+    }
+    interface IControllerOptionsPassport {
+        actions?: TypeControllerOptionsActions<ControllerPassport>;
+    }
+    interface IControllerOptionsPerformAction {
+        actions?: TypeControllerOptionsActions<ControllerPerformAction>;
+    }
+    interface IControllerOptionsQueue {
+        actions?: TypeControllerOptionsActions<ControllerQueue>;
+    }
+    interface IControllerOptionsSummer {
+        actions?: TypeControllerOptionsActions<ControllerSummer>;
+    }
+    interface IControllerOptionsTail {
+        actions?: TypeControllerOptionsActions<ControllerTail>;
+    }
+    interface IControllerOptionsTransaction {
+        actions?: TypeControllerOptionsActions<ControllerTransaction>;
+    }
+    interface IControllerOptionsUpload {
+        actions?: TypeControllerOptionsActions<ControllerUpload>;
+    }
+}
+declare module 'vona-module-a-web' {
+    interface IApiPathGetRecord {
+        '/test/vona/bean/test': undefined;
+        '/test/vona/bean/service': undefined;
+        '/': undefined;
+        '/test/vona/onion/echo3/:userId': undefined;
+        '/test/vona/onion/echo5': undefined;
+        '/test/vona/onion/echo6': undefined;
+        '/test/vona/passport/echo/:name': undefined;
+        '/test/vona/passport/isAuthenticated': undefined;
+    }
+    interface IApiPathPostRecord {
+        '/test/vona/cacheMem': undefined;
+        '/test/vona/cacheRedis': undefined;
+        '//echo': undefined;
+        '/test/vona/onion/echo2/:userId/:userName': undefined;
+        '/test/vona/onion/echo4': undefined;
+        '/test/vona/passport/login': undefined;
+        '/test/vona/passport/refresh': undefined;
+        '/test/vona/passport/logout': undefined;
+        '/test/vona/performAction/echo': undefined;
+        '/test/vona/queue/pushAsync': undefined;
+        '/test/vona/queue/push': undefined;
+        '/test/vona/summer': undefined;
+        '/test/vona/tail': undefined;
+        '/test/vona/transaction/fail': undefined;
+        '/test/vona/transaction/success': undefined;
+        '/test/vona/upload/fields': undefined;
+        '/test/vona/upload/file': undefined;
+        '/test/vona/upload/files': undefined;
+    }
+}
+export * from '../service/transaction.ts';
+export declare const locales: {
+    'en-us': {
+        User: string;
+        UserId: string;
+        TestHelloWorld: string;
+        TestApples: string;
+        TestApples_0: string;
+        TestApples_1: string;
+        TestNameApples_: string;
+        TestNameApples_0_1: string;
+        TestNameApples_1_1: string;
+    };
+    'zh-cn': {
+        User: string;
+        UserId: string;
+        TestHelloWorld: string;
+        TestApples: string;
+        TestApples_0: string;
+        TestNameApples_: string;
+        TestNameApples_0_1: string;
+    };
+};
+export declare class ScopeModuleTestVona extends BeanScopeBase {
+}
+export interface ScopeModuleTestVona {
+    util: BeanScopeUtil;
+    config: TypeModuleConfig<typeof config>;
+    locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
+    entity: IModuleEntity;
+    model: IModuleModel;
+    broadcast: IModuleBroadcast;
+    cacheMem: IModuleCacheMem;
+    cacheRedis: IModuleCacheRedis;
+    event: IModuleEvent;
+    queue: IModuleQueue;
+    summerCache: IModuleSummerCache;
+    service: IModuleService;
+}
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'test-vona': ScopeModuleTestVona;
+    }
+    interface IBeanScopeContainer {
+        testVona: ScopeModuleTestVona;
+    }
+    interface IBeanScopeConfig {
+        'test-vona': ReturnType<typeof config>;
+    }
+    interface IBeanScopeLocale {
+        'test-vona': (typeof locales)[TypeLocaleBase];
+    }
+}
+export declare function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `test-vona::${K}`;
+/** scope: end */

package/dist/.metadata/this.d.ts

@@ -0,0 +1,2 @@
+export declare const __ThisModule__ = "test-vona";
+export { ScopeModuleTestVona as ScopeModule } from './index.ts';

package/dist/bean/aop.regExp.d.ts

@@ -0,0 +1,7 @@
+import { BeanAopBase } from 'vona';
+export declare class AopRegExp extends BeanAopBase {
+    __get_name__(next: any): string;
+    __set_name__(value: any, next: any): any;
+    actionSync(_args: any, next: any): string;
+    actionAsync(_args: any, next: any): Promise<string>;
+}

package/dist/bean/aop.simple.d.ts

@@ -0,0 +1,14 @@
+import type { Next } from 'vona';
+import type { BeanTestCtx } from 'vona-module-test-vona';
+import { BeanAopBase } from 'vona';
+declare class AopSimpleBase extends BeanAopBase {
+    actionSync(_args: any, next: any): string;
+}
+export declare class AopSimple extends AopSimpleBase {
+    __get__(prop: any, next: any): any;
+    __set__(prop: any, value: any, next: any): boolean;
+    __get_name__(next: any): string;
+    __set_name__(value: any, next: any): boolean;
+    actionAsync(_args: Parameters<BeanTestCtx['actionAsync']>, next: Next, _receiver: BeanTestCtx): Promise<string>;
+}
+export {};

package/dist/bean/aopMethod.test.d.ts

@@ -0,0 +1,13 @@
+import type { Next, NextSync } from 'vona';
+import type { IAopMethodExecute, IAopMethodGet, IAopMethodSet, IDecoratorAopMethodOptions } from 'vona-module-a-aspect';
+import { BeanAopMethodBase } from 'vona';
+export interface IAopMethodOptionsTest extends IDecoratorAopMethodOptions {
+    wrapper: string;
+}
+export declare class AopMethodTest extends BeanAopMethodBase implements IAopMethodGet, IAopMethodSet, IAopMethodExecute {
+    get(options: IAopMethodOptionsTest, next: NextSync, _receiver: any, _prop: string): string;
+    set(options: IAopMethodOptionsTest, value: string, next: NextSync, _receiver: any, _prop: string): boolean;
+    execute(options: IAopMethodOptionsTest, _args: [], next: Next | NextSync, _receiver: any, _prop: string): Promise<string> | string;
+    _wrapper(wrapper: string, data: string): string;
+    _unwrapper(wrapper: string, data: string): string;
+}

package/dist/bean/bean.testCtx.d.ts

@@ -0,0 +1,21 @@
+import { BeanBase } from 'vona';
+declare class TestCtx0 extends BeanBase {
+    _name: string;
+    protected __init__(moduleName: any): void;
+    protected __get__(prop: any): any;
+    protected __set__(prop: any, value: any): boolean;
+    get name(): string;
+    set name(value: string);
+    actionSync({ a, b }: any): any;
+    actionAsync({ a, b }: {
+        a: number;
+        b: number;
+    }): Promise<number>;
+    actionAsync2({ a, b }: any): Promise<string>;
+}
+declare class TestCtx1 extends TestCtx0 {
+    actionAsync3({ a, b }: any): Promise<string>;
+}
+export declare class BeanTestCtx extends TestCtx1 {
+}
+export {};

package/dist/bean/broadcast.test.d.ts

@@ -0,0 +1,8 @@
+import type { IBroadcastExecute } from 'vona-module-a-broadcast';
+import { BeanBroadcastBase } from 'vona-module-a-broadcast';
+export interface TypeBroadcastTestJobData {
+    message: string;
+}
+export declare class BroadcastTest extends BeanBroadcastBase<TypeBroadcastTestJobData> implements IBroadcastExecute<TypeBroadcastTestJobData> {
+    execute(data: TypeBroadcastTestJobData, isEmitter?: boolean): Promise<void>;
+}

package/dist/bean/cacheMem.test.d.ts

@@ -0,0 +1,5 @@
+import { BeanCacheMemBase } from 'vona-module-a-cache';
+export type TCacheMemTestKey = never;
+export type TCacheMemTestData = string;
+export declare class CacheMemTest extends BeanCacheMemBase<TCacheMemTestKey, TCacheMemTestData> {
+}

package/dist/bean/cacheRedis.test.d.ts

@@ -0,0 +1,5 @@
+import { BeanCacheRedisBase } from 'vona-module-a-cache';
+export type TCacheRedisTestKey = any;
+export type TCacheRedisTestData = string;
+export declare class CacheRedisTest extends BeanCacheRedisBase<TCacheRedisTestKey, TCacheRedisTestData> {
+}

package/dist/bean/event.helloEcho.d.ts

@@ -0,0 +1,7 @@
+import { BeanEventBase } from 'vona-module-a-event';
+export interface TypeEventHelloEchoData {
+    text: string;
+}
+export type TypeEventHelloEchoResult = string;
+export declare class EventHelloEcho extends BeanEventBase<TypeEventHelloEchoData, TypeEventHelloEchoResult> {
+}

package/dist/bean/eventListener.helloEcho.d.ts

@@ -0,0 +1,9 @@
+import type { IEventExecute, NextEvent } from 'vona-module-a-event';
+import type { TypeEventHelloEchoData, TypeEventHelloEchoResult } from './event.helloEcho.ts';
+import { BeanBase } from 'vona';
+type TypeEventData = TypeEventHelloEchoData;
+type TypeEventResult = TypeEventHelloEchoResult;
+export declare class EventListenerHelloEcho extends BeanBase implements IEventExecute<TypeEventData, TypeEventResult> {
+    execute(data: TypeEventData, next: NextEvent<TypeEventData, TypeEventResult>): Promise<TypeEventResult>;
+}
+export {};

package/dist/bean/meta.version.d.ts

@@ -0,0 +1,5 @@
+import type { IMetaVersionUpdate, IMetaVersionUpdateOptions } from 'vona-module-a-version';
+import { BeanBase } from 'vona';
+export declare class MetaVersion extends BeanBase implements IMetaVersionUpdate {
+    update(options: IMetaVersionUpdateOptions): Promise<void>;
+}

package/dist/bean/queue.test.d.ts

@@ -0,0 +1,10 @@
+import type { IQueueExecute, IQueuePushOptions } from 'vona-module-a-queue';
+import { BeanQueueBase } from 'vona-module-a-queue';
+export interface TypeQueueTestJobData {
+    a: number;
+    b: number;
+}
+export type TypeQueueTestJobResult = number;
+export declare class QueueTest extends BeanQueueBase<TypeQueueTestJobData, TypeQueueTestJobResult> implements IQueueExecute<TypeQueueTestJobData, TypeQueueTestJobResult> {
+    execute(data: TypeQueueTestJobData, _options?: IQueuePushOptions): Promise<TypeQueueTestJobResult>;
+}

package/dist/bean/schedule.test.d.ts

@@ -0,0 +1,5 @@
+import type { IScheduleExecute, TypeScheduleJob } from 'vona-module-a-schedule';
+import { BeanBase } from 'vona';
+export declare class ScheduleTest extends BeanBase implements IScheduleExecute {
+    execute(job?: TypeScheduleJob): Promise<void>;
+}