@chevre/domain 26.0.0-alpha.0 → 26.0.0-alpha.10

package/lib/chevre/repo/task.js

@@ -23,23 +23,6 @@ const executableTaskProjection = {
     runsAt: 1,
     expires: 1
 };
-const AVAILABLE_PROJECT_FIELDS = [
-    'alternateName',
-    'identifier',
-    'description',
-    'project',
-    'name',
-    'status',
-    'runsAt',
-    'remainingNumberOfTries',
-    'lastTriedAt',
-    'numberOfTried',
-    'executionResults',
-    'executor',
-    'data',
-    'dateAborted',
-    'expires'
-];
 /**
  * タスクリポジトリ
  */
@@ -48,31 +31,6 @@ class TaskRepo {
     constructor(connection) {
         this.taskModel = connection.model(task_2.modelName, (0, task_2.createSchema)());
     }
-    async runImmediately(params, 
-    // support customr function(2025-05-25~)
-    next) {
-        const { expires } = params;
-        if (!(expires instanceof Date)) {
-            throw new factory_1.factory.errors.Argument('expires', 'must be Date');
-        }
-        const savingTask = {
-            ...params,
-            status: factory_1.factory.taskStatus.Ready,
-            numberOfTried: 0,
-            executionResults: []
-        };
-        const result = await this.taskModel.insertMany(savingTask, { rawResult: true });
-        const id = result.insertedIds?.[0]?.toHexString();
-        if (typeof id !== 'string') {
-            throw new factory_1.factory.errors.Internal('task not saved');
-        }
-        task_1.taskEventEmitter.emitTaskStatusChanged({
-            id,
-            status: factory_1.factory.taskStatus.Ready,
-            expires // emit expires(2025-03-31~)
-        }, next);
-        return { id };
-    }
     async saveMany(taskAttributes) {
         const emitImmediately = true; // always true(2026-07-30~)
         // const emitImmediately = options?.emitImmediately === true;
@@ -132,17 +90,24 @@ class TaskRepo {
     /**
      * タスク識別子から冪等作成する
      * reimplement createIfNotExistByIdentifier(2025-03-28~)
+     * reimplement runTaskByIdentifier(2026-08-03~)
      */
-    async createIfNotExistByAlternateName(params) {
+    async runTaskByIdentifier(params) {
         const emitImmediately = true; // always true(2026-07-30~)
+        if (typeof params.identifier !== 'string' || params.identifier.length === 0) {
+            throw new factory_1.factory.errors.ArgumentNull('identifier');
+        }
         if (typeof params.alternateName !== 'string' || params.alternateName.length === 0) {
             throw new factory_1.factory.errors.ArgumentNull('alternateName');
         }
+        if (params.identifier !== params.alternateName) {
+            throw new factory_1.factory.errors.Argument('identifier,alternateName not matched');
+        }
         let createdTask;
         const filterQuery = {
             'project.id': { $eq: params.project.id },
             name: { $eq: params.name },
-            alternateName: { $exists: true, $eq: params.alternateName }
+            identifier: { $exists: true, $eq: params.identifier }
         };
         const projection = {
             _id: 0,
@@ -160,7 +125,7 @@ class TaskRepo {
         catch (error) {
             let throwsError = true;
             if (await (0, errorHandler_1.isMongoDuplicateError)(error)) {
-                // すでにalternateNameが存在する場合ok
+                // すでにidentifierが存在する場合ok
                 throwsError = false;
                 createdTask = await this.taskModel.findOne(filterQuery, projection)
                     .lean()
@@ -180,7 +145,7 @@ class TaskRepo {
             }
         }
         else {
-            throw new factory_1.factory.errors.Internal(`falied in creating a task unexpectedly. ${params.alternateName}`);
+            throw new factory_1.factory.errors.Internal(`falied in creating a task unexpectedly. ${params.identifier}`);
         }
     }
     // /**
@@ -284,58 +249,76 @@ class TaskRepo {
         }
         return doc;
     }
+    // 不要なので廃止(2026-08-04~)
+    // /**
+    //  * Readyのタスクをname指定でひとつRunningに変更する
+    //  */
+    // public async executeOneIfExists(params: {
+    //     name: {
+    //         $eq: factory.taskName;
+    //         // $nin?: factory.taskName[]; // discontinue(2025-08-07~)
+    //     };
+    //     executor: { name: string };
+    //     runsAt: {
+    //         $lt: Date;
+    //     };
+    //     sort: {
+    //         numberOfTried?: factory.sortType; // トライ回数の少なさ優先
+    //         runsAt?: factory.sortType; // 実行予定日時の早さ優先
+    //     };
+    // }): Promise<IExecutableTask<factory.taskName> | null> {
+    //     if (!(params.runsAt.$lt instanceof Date)) {
+    //         throw new factory.errors.Argument('runsAt.$lt', 'must be Date');
+    //     }
+    //     const nameEq = params.name?.$eq;
+    //     // const nameNin = params.name?.$nin;
+    //     const doc = await this.taskModel.findOneAndUpdate(
+    //         {
+    //             status: { $eq: factory.taskStatus.Ready },
+    //             runsAt: { $lt: params.runsAt.$lt },
+    //             ...(typeof nameEq === 'string')
+    //                 ? {
+    //                     name: {
+    //                         ...(typeof nameEq === 'string') ? { $eq: nameEq } : undefined
+    //                         // ...(Array.isArray(nameNin)) ? { $nin: nameNin } : undefined
+    //                     }
+    //                 }
+    //                 : undefined
+    //         },
+    //         {
+    //             $set: {
+    //                 status: factory.taskStatus.Running, // 実行中に変更
+    //                 lastTriedAt: new Date(),
+    //                 executor: params.executor
+    //             },
+    //             $inc: {
+    //                 remainingNumberOfTries: -1, // 残りトライ可能回数減らす
+    //                 numberOfTried: 1 // トライ回数増やす
+    //             }
+    //         },
+    //         {
+    //             new: true,
+    //             projection: executableTaskProjection,
+    //             ...(typeof params.sort.numberOfTried === 'number' || typeof params.sort.runsAt === 'number')
+    //                 ? { sort: params.sort }
+    //                 : undefined
+    //         }
+    //     )
+    //         .setOptions({ maxTimeMS: MONGO_MAX_TIME_MS })
+    //         .lean<IExecutableTask<factory.taskName>>()  // lean(2024-09-26~)
+    //         .exec();
+    //     if (doc === null) {
+    //         return null;
+    //     }
+    //     return doc;
+    // }
     /**
-     * Readyのタスクをname指定でひとつRunningに変更する
-     */
-    async executeOneIfExists(params) {
-        if (!(params.runsAt.$lt instanceof Date)) {
-            throw new factory_1.factory.errors.Argument('runsAt.$lt', 'must be Date');
-        }
-        const nameEq = params.name?.$eq;
-        // const nameNin = params.name?.$nin;
-        const doc = await this.taskModel.findOneAndUpdate({
-            status: { $eq: factory_1.factory.taskStatus.Ready },
-            runsAt: { $lt: params.runsAt.$lt },
-            ...(typeof nameEq === 'string')
-                ? {
-                    name: {
-                        ...(typeof nameEq === 'string') ? { $eq: nameEq } : undefined
-                        // ...(Array.isArray(nameNin)) ? { $nin: nameNin } : undefined
-                    }
-                }
-                : undefined
-        }, {
-            $set: {
-                status: factory_1.factory.taskStatus.Running, // 実行中に変更
-                lastTriedAt: new Date(),
-                executor: params.executor
-            },
-            $inc: {
-                remainingNumberOfTries: -1, // 残りトライ可能回数減らす
-                numberOfTried: 1 // トライ回数増やす
-            }
-        }, {
-            new: true,
-            projection: executableTaskProjection,
-            ...(typeof params.sort.numberOfTried === 'number' || typeof params.sort.runsAt === 'number')
-                ? { sort: params.sort }
-                : undefined
-        })
-            .setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
-            .lean() // lean(2024-09-26~)
-            .exec();
-        if (doc === null) {
-            return null;
-        }
-        return doc;
-    }
-    /**
+     * 潜在的に実行されるべきタスクをカウントする
      * add(2025-03-16~)
      */
     async countPotentiallyRunning(params) {
         const { runsAt, limit, name } = params;
         const nameEq = name?.$eq;
-        // const nameNin = name?.$nin;
         const nameIn = name?.$in;
         if (!(runsAt.$lt instanceof Date)) {
             throw new factory_1.factory.errors.Argument('runsAt.$lt', 'must be Date');
@@ -347,7 +330,6 @@ class TaskRepo {
                 ? {
                     name: {
                         ...(typeof nameEq === 'string') ? { $eq: nameEq } : undefined,
-                        // ...(Array.isArray(nameNin)) ? { $nin: nameNin } : undefined,
                         ...(Array.isArray(nameIn)) ? { $in: nameIn } : undefined
                     }
                 }
@@ -361,28 +343,16 @@ class TaskRepo {
         return { count };
     }
     /**
-     * 実行日時を一定期間過ぎたReadyタスクについて、Runningスタータスに変更した上で、Runningイベントを発生させる
+     * 実行日時を一定期間過ぎたReadyタスクについて、Runningステータスに変更する
      */
-    async emitRunningIfExists(params) {
-        if (!(params.runsAt.$lt instanceof Date)) {
-            throw new factory_1.factory.errors.Argument('runsAt.$lt', 'must be Date');
-        }
+    async runDelayedTask(params) {
+        const { filter } = params;
         const projection = {
             _id: 0,
             id: { $toString: '$_id' },
             name: 1
         };
-        const nameEq = params.name?.$eq;
-        // const nameNin = params.name?.$nin;
-        // const nameIn = params.name?.$in;
-        const { nameFilterBeforeRunsAt } = params;
-        const filter = {
-            status: { $eq: factory_1.factory.taskStatus.Ready },
-            ...(nameFilterBeforeRunsAt) ? { name: params.name } : undefined,
-            runsAt: { $lt: params.runsAt.$lt },
-            ...(!nameFilterBeforeRunsAt) ? { name: params.name } : undefined
-        };
-        const doc = await this.taskModel.findOneAndUpdate(filter, {
+        return this.taskModel.findOneAndUpdate(filter, {
             $set: {
                 status: factory_1.factory.taskStatus.Running, // 実行中に変更
                 lastTriedAt: new Date(),
@@ -402,9 +372,58 @@ class TaskRepo {
             .setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
             .lean()
             .exec();
+    }
+    /**
+     * 実行日時を一定期間過ぎたReadyタスクについて、Runningステータスに変更した上で、Runningイベントを発生させる
+     */
+    async emitRunningIfExistsByName(params) {
+        if (!(params.runsAt.$lt instanceof Date)) {
+            throw new factory_1.factory.errors.Argument('runsAt.$lt', 'must be Date');
+        }
+        // const projection: ProjectionType<IDocType> = {
+        //     _id: 0,
+        //     id: { $toString: '$_id' },
+        //     name: 1
+        // };
+        // インデックス'executeOneByNameIfExists'を想定したfilter
+        const filter = {
+            status: { $eq: factory_1.factory.taskStatus.Ready },
+            runsAt: { $lt: params.runsAt.$lt },
+            name: params.name
+        };
+        const doc = await this.runDelayedTask({
+            filter,
+            sort: params.sort,
+            executor: params.executor
+        });
+        // const doc = await this.taskModel.findOneAndUpdate(
+        //     filter,
+        //     {
+        //         $set: {
+        //             status: factory.taskStatus.Running, // 実行中に変更
+        //             lastTriedAt: new Date(),
+        //             executor: params.executor
+        //         },
+        //         $inc: {
+        //             remainingNumberOfTries: -1, // 残りトライ可能回数減らす
+        //             numberOfTried: 1 // トライ回数増やす
+        //         }
+        //     },
+        //     {
+        //         new: true,
+        //         projection,
+        //         ...(typeof params.sort.numberOfTried === 'number' || typeof params.sort.runsAt === 'number')
+        //             ? { sort: params.sort }
+        //             : undefined
+        //     }
+        // )
+        //     .setOptions({ maxTimeMS: MONGO_MAX_TIME_MS })
+        //     .lean<Pick<factory.task.ITask<factory.taskName>, 'id' | 'name'>>()
+        //     .exec();
         if (doc === null) {
             return null;
         }
+        const nameEq = params.name?.$eq;
         let changedTask;
         if (typeof nameEq === 'string') {
             changedTask = {
@@ -423,32 +442,78 @@ class TaskRepo {
         return doc;
     }
     /**
-     * Readyのままで期限切れのタスクをExpiredに変更する
+     * 実行日時を一定期間過ぎたReadyタスクについて、Runningステータスに変更した上で、Runningイベントを発生させる
+     * taskNameで絞らない
+     * 2026-08-04~
      */
-    async makeExpiredMany(params) {
-        const { expiresLt } = params;
-        if (!(expiresLt instanceof Date)) {
-            throw new factory_1.factory.errors.Argument('expiresLt', 'must be Date');
+    async emitRunningIfExistsNoName(params) {
+        if (!(params.runsAt.$lt instanceof Date)) {
+            throw new factory_1.factory.errors.Argument('runsAt.$lt', 'must be Date');
         }
-        return this.taskModel.updateMany({
+        // インデックス'executeOneByNameIfExists'を想定したfilter
+        const filter = {
             status: { $eq: factory_1.factory.taskStatus.Ready },
-            expires: { $exists: true, $lt: expiresLt }
+            runsAt: { $lt: params.runsAt.$lt }
+        };
+        const doc = await this.runDelayedTask({
+            filter,
+            sort: {
+                runsAt: factory_1.factory.sortType.Ascending // ソートはrunsAtのみにしてみる(2026-08-04~)
+            },
+            executor: params.executor
+        });
+        if (doc === null) {
+            return null;
+        }
+        const changedTask = {
+            id: doc.id,
+            status: factory_1.factory.taskStatus.Running
+        };
+        task_1.taskEventEmitter.emitTaskStatusChanged(changedTask);
+        return doc;
+    }
+    /**
+     * Runningのまま一定期間超過し、かつ、remainingNumberOfTries>0のタスクをReadyに変更する
+     */
+    async retryTasks(params) {
+        const lastTriedAtShoudBeLessThan = (0, moment_1.default)()
+            .add(-params.intervalInMinutes, 'minutes')
+            .toDate();
+        // const remainingNumberOfTriesGte = params.remainingNumberOfTries.$gte;
+        // const remainingNumberOfTriesLte = params.remainingNumberOfTries.$lte;
+        return this.taskModel.updateMany(
+        // name: 'retry'のindexと連動しているので、条件の順序などには注意すること
+        // @see schemas/task
+        {
+            status: { $eq: factory_1.factory.taskStatus.Running },
+            lastTriedAt: {
+                $type: 'date',
+                $lt: lastTriedAtShoudBeLessThan
+            },
+            remainingNumberOfTries: { $gte: 1 },
+            // ...(typeof remainingNumberOfTriesGte === 'number')
+            //     ? { remainingNumberOfTries: { $gte: remainingNumberOfTriesGte } }
+            //     : undefined,
+            // ...(typeof remainingNumberOfTriesLte === 'number')
+            //     ? { remainingNumberOfTries: { $lte: remainingNumberOfTriesLte } }
+            //     : undefined,
+            // ...(Array.isArray(params.name.$in)) ? { name: { $in: params.name.$in } } : undefined
         }, {
             $set: {
-                status: factory_1.factory.taskStatus.Expired
+                status: factory_1.factory.taskStatus.Ready // 実行前に変更
             }
         })
             .exec();
     }
     /**
-     * Runningのまま一定期間超過し、かつ、remainingNumberOfTries>0のタスクをReadyに変更する
+     * $lte:0をReadyにする(特定のタスクを除いて) -> Readyにすれば自動的にAbortedになる
      */
-    async retryMany(params) {
+    async retryAbortingTasksByName(params) {
         const lastTriedAtShoudBeLessThan = (0, moment_1.default)()
             .add(-params.intervalInMinutes, 'minutes')
             .toDate();
-        const remainingNumberOfTriesGte = params.remainingNumberOfTries.$gte;
-        const remainingNumberOfTriesLte = params.remainingNumberOfTries.$lte;
+        // const remainingNumberOfTriesGte = params.remainingNumberOfTries.$gte;
+        // const remainingNumberOfTriesLte = params.remainingNumberOfTries.$lte;
         return this.taskModel.updateMany(
         // name: 'retry'のindexと連動しているので、条件の順序などには注意すること
         // @see schemas/task
@@ -458,12 +523,13 @@ class TaskRepo {
                 $type: 'date',
                 $lt: lastTriedAtShoudBeLessThan
             },
-            ...(typeof remainingNumberOfTriesGte === 'number')
-                ? { remainingNumberOfTries: { $gte: remainingNumberOfTriesGte } }
-                : undefined,
-            ...(typeof remainingNumberOfTriesLte === 'number')
-                ? { remainingNumberOfTries: { $lte: remainingNumberOfTriesLte } }
-                : undefined,
+            remainingNumberOfTries: { $lte: 0 },
+            // ...(typeof remainingNumberOfTriesGte === 'number')
+            //     ? { remainingNumberOfTries: { $gte: remainingNumberOfTriesGte } }
+            //     : undefined,
+            // ...(typeof remainingNumberOfTriesLte === 'number')
+            //     ? { remainingNumberOfTries: { $lte: remainingNumberOfTriesLte } }
+            //     : undefined,
             ...(Array.isArray(params.name.$in)) ? { name: { $in: params.name.$in } } : undefined
         }, {
             $set: {
@@ -472,6 +538,30 @@ class TaskRepo {
         })
             .exec();
     }
+    /**
+     * $lte:0をReadyにする(特定のタスクを除いて) -> Readyにすれば自動的にAbortedになる
+     */
+    async retryAbortingTasks(params) {
+        const lastTriedAtShoudBeLessThan = (0, moment_1.default)()
+            .add(-params.intervalInMinutes, 'minutes')
+            .toDate();
+        return this.taskModel.updateMany(
+        // name: 'retry'のindexと連動しているので、条件の順序などには注意すること
+        // @see schemas/task
+        {
+            status: { $eq: factory_1.factory.taskStatus.Running },
+            lastTriedAt: {
+                $type: 'date',
+                $lt: lastTriedAtShoudBeLessThan
+            },
+            remainingNumberOfTries: { $lte: 0 }
+        }, {
+            $set: {
+                status: factory_1.factory.taskStatus.Ready // 実行前に変更
+            }
+        })
+            .exec();
+    }
     /**
      * 実行中止済タスクを強制的にリトライ
      * 中止済タスクでなければ何もしない
@@ -490,26 +580,6 @@ class TaskRepo {
         })
             .exec();
     }
-    async abortMany(params) {
-        const lastTriedAtShoudBeLessThan = (0, moment_1.default)()
-            .add(-params.intervalInMinutes, 'minutes')
-            .toDate();
-        return this.taskModel.updateMany({
-            status: { $eq: factory_1.factory.taskStatus.Running },
-            lastTriedAt: {
-                $type: 'date',
-                $lt: lastTriedAtShoudBeLessThan
-            },
-            remainingNumberOfTries: { $eq: 0 },
-            ...(Array.isArray(params.name.$in)) ? { name: { $in: params.name.$in } } : undefined
-        }, {
-            $set: {
-                status: factory_1.factory.taskStatus.Aborted,
-                dateAborted: new Date()
-            }
-        })
-            .exec();
-    }
     /**
      * タスクIDから実行結果とステータスを保管する
      * Abortedの場合、dateAbortedもセットする
@@ -533,36 +603,46 @@ class TaskRepo {
             task_1.taskEventEmitter.emitTaskStatusChanged(changedTask, next);
         }
     }
-    /**
-     * タスクの状態を参照する
-     * 非同期アクション移行が完了したら廃止する(2026-07-29~)
-     */
-    async findTaskById(params, inclusion) {
-        let positiveProjectionFields = AVAILABLE_PROJECT_FIELDS;
-        if (Array.isArray(inclusion) && inclusion.length > 0) {
-            positiveProjectionFields = inclusion.filter((key) => AVAILABLE_PROJECT_FIELDS.includes(key));
-        }
-        else {
-            // no op
-        }
-        const projection = {
-            _id: 0,
-            id: { $toString: '$_id' },
-            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
-        };
-        const query = this.taskModel.findOne({
-            _id: { $eq: params.id.$eq },
-            'project.id': { $eq: params.project.id.$eq },
-            name: { $eq: params.name }
-        }, projection);
-        const doc = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
-            .lean()
-            .exec();
-        if (doc === null) {
-            return;
-        }
-        return doc;
-    }
+    // 非同期アクションへ移行したので不要(2026-08-04~)
+    // /**
+    //  * タスクの状態を参照する
+    //  * 非同期アクション移行が完了したら廃止する(2026-07-29~)
+    //  */
+    // public async findTaskById(
+    //     params: {
+    //         id: { $eq: string };
+    //         project: { id: { $eq: string } };
+    //         name: factory.taskName
+    //     },
+    //     inclusion: IKeyOfProjection[]
+    // ): Promise<(IDocType & { id: string } | undefined)> {
+    //     let positiveProjectionFields: IKeyOfProjection[] = AVAILABLE_PROJECT_FIELDS;
+    //     if (Array.isArray(inclusion) && inclusion.length > 0) {
+    //         positiveProjectionFields = inclusion.filter((key) => AVAILABLE_PROJECT_FIELDS.includes(key));
+    //     } else {
+    //         // no op
+    //     }
+    //     const projection: ProjectionType<IDocType> = {
+    //         _id: 0,
+    //         id: { $toString: '$_id' },
+    //         ...Object.fromEntries<1>(positiveProjectionFields.map((key) => ([key, 1])))
+    //     };
+    //     const query = this.taskModel.findOne(
+    //         {
+    //             _id: { $eq: params.id.$eq },
+    //             'project.id': { $eq: params.project.id.$eq },
+    //             name: { $eq: params.name }
+    //         },
+    //         projection
+    //     );
+    //     const doc = await query.setOptions({ maxTimeMS: MONGO_MAX_TIME_MS })
+    //         .lean<IDocType & { id: string }>()
+    //         .exec();
+    //     if (doc === null) {
+    //         return;
+    //     }
+    //     return doc;
+    // }
     async deleteByProject(params) {
         await this.taskModel.deleteMany({
             'project.id': { $eq: params.project.id }

package/lib/chevre/repository.d.ts

@@ -16,12 +16,16 @@ import type { CheckThingActionRepo } from './repo/action/checkThing';
 import type { PayActionRepo } from './repo/action/pay';
 import type { RefundActionRepo } from './repo/action/refund';
 import type { AsyncActionRepo } from './repo/asyncAction';
+import type { AsyncActionLegacyRepo } from './repo/asyncActionLegacy';
 import type { AdditionalPropertyRepo } from './repo/additionalProperty';
+import type { AdminAsyncActionRepo } from './repo/adminAsyncAction';
+import type { AdminScheduledTaskRepo } from './repo/adminScheduledTask';
 import type { AdminTaskRepo } from './repo/adminTask';
 import type { AggregateActionRepo } from './repo/aggregateAction';
 import type { AggregateOfferRepo } from './repo/aggregateOffer';
 import type { AggregateOrderRepo } from './repo/aggregateOrder';
 import type { AggregateReservationRepo } from './repo/aggregateReservation';
+import type { AggregateScheduledTaskRepo } from './repo/aggregateScheduledTask';
 import type { AggregateTaskRepo } from './repo/aggregateTask';
 import type { AggregationRepo } from './repo/aggregation';
 import type { AssetTransactionRepo } from './repo/assetTransaction';
@@ -89,6 +93,7 @@ import type { RateLimitSettingRepo } from './repo/setting/rateLimit';
 import type { WaiterSettingRepo } from './repo/setting/waiter';
 import type { StockHolderRepo } from './repo/stockHolder';
 import type { ScheduledTaskRepo } from './repo/scheduledTask';
+import type { ScheduledTaskLegacyRepo } from './repo/scheduledTaskLegacy';
 import type { TaskRepo } from './repo/task';
 import type { TicketRepo } from './repo/ticket';
 import type { TransactionRepo } from './repo/transaction';
@@ -162,6 +167,14 @@ export type AdditionalProperty = AdditionalPropertyRepo;
 export declare namespace AdditionalProperty {
     function createInstance(...params: ConstructorParameters<typeof AdditionalPropertyRepo>): Promise<AdditionalPropertyRepo>;
 }
+export type AdminAsyncAction = AdminAsyncActionRepo;
+export declare namespace AdminAsyncAction {
+    function createInstance(...params: ConstructorParameters<typeof AdminAsyncActionRepo>): Promise<AdminAsyncActionRepo>;
+}
+export type AdminScheduledTask = AdminScheduledTaskRepo;
+export declare namespace AdminScheduledTask {
+    function createInstance(...params: ConstructorParameters<typeof AdminScheduledTaskRepo>): Promise<AdminScheduledTaskRepo>;
+}
 export type AdminTask = AdminTaskRepo;
 export declare namespace AdminTask {
     function createInstance(...params: ConstructorParameters<typeof AdminTaskRepo>): Promise<AdminTaskRepo>;
@@ -170,6 +183,10 @@ export type AggregateAction = AggregateActionRepo;
 export declare namespace AggregateAction {
     function createInstance(...params: ConstructorParameters<typeof AggregateActionRepo>): Promise<AggregateActionRepo>;
 }
+export type AggregateScheduledTask = AggregateScheduledTaskRepo;
+export declare namespace AggregateScheduledTask {
+    function createInstance(...params: ConstructorParameters<typeof AggregateScheduledTaskRepo>): Promise<AggregateScheduledTaskRepo>;
+}
 export type AggregateTask = AggregateTaskRepo;
 export declare namespace AggregateTask {
     function createInstance(...params: ConstructorParameters<typeof AggregateTaskRepo>): Promise<AggregateTaskRepo>;
@@ -482,6 +499,10 @@ export type ScheduledTask = ScheduledTaskRepo;
 export declare namespace ScheduledTask {
     function createInstance(...params: ConstructorParameters<typeof ScheduledTaskRepo>): Promise<ScheduledTaskRepo>;
 }
+export type ScheduledTaskLegacy = ScheduledTaskLegacyRepo;
+export declare namespace ScheduledTaskLegacy {
+    function createInstance(...params: ConstructorParameters<typeof ScheduledTaskLegacyRepo>): Promise<ScheduledTaskLegacyRepo>;
+}
 export type Task = TaskRepo;
 export declare namespace Task {
     function createInstance(...params: ConstructorParameters<typeof TaskRepo>): Promise<TaskRepo>;
@@ -490,6 +511,10 @@ export type AsyncAction = AsyncActionRepo;
 export declare namespace AsyncAction {
     function createInstance(...params: ConstructorParameters<typeof AsyncActionRepo>): Promise<AsyncActionRepo>;
 }
+export type AsyncActionLegacy = AsyncActionLegacyRepo;
+export declare namespace AsyncActionLegacy {
+    function createInstance(...params: ConstructorParameters<typeof AsyncActionLegacyRepo>): Promise<AsyncActionLegacyRepo>;
+}
 export type Ticket = TicketRepo;
 export declare namespace Ticket {
     function createInstance(...params: ConstructorParameters<typeof TicketRepo>): Promise<TicketRepo>;