@chevre/domain 21.8.0-alpha.4 → 21.8.0-alpha.41

package/example/src/chevre/syncAggregateOffer.ts

@@ -0,0 +1,25 @@
+// tslint:disable:no-console
+// import * as redis from 'redis';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const offerRepo = new chevre.repository.Offer(mongoose.connection);
+
+    const result = await offerRepo.sync2aggregateOffer({
+        project: { id: project.id },
+        identifier: { $in: ['COA-120-15'] },
+        isDeleted: false,
+        typeOf: chevre.factory.offerType.Offer
+    });
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/lib/chevre/repo/assetTransaction.d.ts

@@ -78,7 +78,14 @@ export declare class MongoRepository {
     confirm<T extends factory.assetTransactionType>(params: {
         typeOf: T;
         id: string;
-        object?: Pick<factory.assetTransaction.reserve.IObject, 'underName'>;
+        object?: Pick<factory.assetTransaction.reserve.IObject, 'underName'> & {
+            /**
+             * 決済取引における決済方法区分指定
+             */
+            paymentMethod?: {
+                identifier?: string;
+            };
+        };
         result: factory.assetTransaction.IResult<T>;
         potentialActions: factory.assetTransaction.IPotentialActions<T>;
     }): Promise<void>;
@@ -182,6 +189,14 @@ export declare class MongoRepository {
         id: string;
         update: any;
     }): Promise<factory.assetTransaction.ITransaction<T>>;
+    migratePaymentMethodIdentifier(params: {
+        transactionNumber: string;
+        object: {
+            paymentMethod: {
+                identifier: string;
+            };
+        };
+    }): Promise<any>;
     findByIdAndDelete(params: {
         id: string;
     }): Promise<void>;

package/lib/chevre/repo/assetTransaction.js

@@ -344,14 +344,16 @@ class MongoRepository {
      * 取引を確定する
      */
     confirm(params) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             const doc = yield this.transactionModel.findOneAndUpdate({
                 _id: { $eq: params.id },
                 typeOf: { $eq: params.typeOf },
                 status: { $eq: factory.transactionStatusType.InProgress }
-            }, Object.assign({ status: factory.transactionStatusType.Confirmed, endDate: new Date(), result: params.result, potentialActions: params.potentialActions }, (typeof ((_b = (_a = params.object) === null || _a === void 0 ? void 0 : _a.underName) === null || _b === void 0 ? void 0 : _b.typeOf) === 'string')
+            }, Object.assign(Object.assign({ status: factory.transactionStatusType.Confirmed, endDate: new Date(), result: params.result, potentialActions: params.potentialActions }, (typeof ((_b = (_a = params.object) === null || _a === void 0 ? void 0 : _a.underName) === null || _b === void 0 ? void 0 : _b.typeOf) === 'string')
                 ? { 'object.underName': params.object.underName }
+                : undefined), (typeof ((_d = (_c = params.object) === null || _c === void 0 ? void 0 : _c.paymentMethod) === null || _d === void 0 ? void 0 : _d.identifier) === 'string')
+                ? { 'object.paymentMethod.identifier': params.object.paymentMethod.identifier }
                 : undefined), {
                 new: true,
                 projection: { _id: 1 }
@@ -704,6 +706,55 @@ class MongoRepository {
             });
         });
     }
+    migratePaymentMethodIdentifier(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.transactionModel.findOneAndUpdate({
+                typeOf: { $eq: factory.assetTransactionType.Pay },
+                transactionNumber: { $exists: true, $eq: params.transactionNumber }
+            }, { 'object.paymentMethod.identifier': params.object.paymentMethod.identifier }, {
+                new: true,
+                projection: { _id: 1 }
+            })
+                .exec()
+                .then((doc) => {
+                if (doc === null) {
+                    throw new factory.errors.ArgumentNull(this.transactionModel.modelName);
+                }
+                return doc.toObject();
+            });
+        });
+    }
+    // public async migratePaymentMethodIdentifierMany() {
+    //     // return this.transactionModel.updateMany(
+    //     //     {
+    //     //         typeOf: { $eq: factory.assetTransactionType.Pay }
+    //     //         // 'object.paymentMethod.identifier': { $exists: false }
+    //     //     },
+    //     //     { $set: { 'object.paymentMethod.identifier': '$object.paymentMethod.typeOf' } }
+    //     // )
+    //     //     .exec();
+    //     return this.transactionModel.aggregate([
+    //         {
+    //             $match: {
+    //                 typeOf: { $eq: factory.assetTransactionType.Pay }
+    //             }
+    //         },
+    //         {
+    //             $project: {
+    //                 paymentMethodIdentifier: '$object.paymentMethod.typeOf'
+    //             }
+    //         },
+    //         {
+    //             $unset: ['object.paymentMethod.identifier']
+    //         }
+    //         // {
+    //         //     $set: {
+    //         //         'object.paymentMethod.identifier': '$paymentMethodIdentifier'
+    //         //     }
+    //         // }
+    //     ])
+    //         .exec();
+    // }
     findByIdAndDelete(params) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.transactionModel.findByIdAndDelete(params.id)
@@ -713,6 +764,7 @@ class MongoRepository {
     getCursor(conditions, projection) {
         return this.transactionModel.find(conditions, projection)
             .sort({ startDate: factory.sortType.Ascending })
+            // .sort({ startDate: factory.sortType.Descending })
             .cursor();
     }
     aggregateAssetTransaction(params) {

package/lib/chevre/repo/mongoose/schemas/aggregateOffer.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { Schema } from 'mongoose';
+declare const modelName = "AggregateOffer";
+/**
+ * 集計オファースキーマ
+ */
+declare const schema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    collection: string;
+    id: true;
+    read: string;
+    writeConcern: import("mongodb").WriteConcern;
+    strict: true;
+    strictQuery: false;
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+    toJSON: {
+        getters: false;
+        virtuals: false;
+        minimize: false;
+        versionKey: false;
+    };
+    toObject: {
+        getters: false;
+        virtuals: true;
+        minimize: false;
+        versionKey: false;
+    };
+}, {
+    offers: any[];
+    _id?: string | undefined;
+    typeOf?: string | undefined;
+    project?: any;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    offers: any[];
+    _id?: string | undefined;
+    typeOf?: string | undefined;
+    project?: any;
+}>> & Omit<import("mongoose").FlatRecord<{
+    offers: any[];
+    _id?: string | undefined;
+    typeOf?: string | undefined;
+    project?: any;
+}> & Required<{
+    _id: string;
+}>, never>>;
+export { modelName, schema };

package/lib/chevre/repo/mongoose/schemas/aggregateOffer.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = exports.modelName = void 0;
+const mongoose_1 = require("mongoose");
+const writeConcern_1 = require("../writeConcern");
+const modelName = 'AggregateOffer';
+exports.modelName = modelName;
+/**
+ * 集計オファースキーマ
+ */
+const schema = new mongoose_1.Schema({
+    project: mongoose_1.SchemaTypes.Mixed,
+    _id: String,
+    typeOf: String,
+    offers: [mongoose_1.SchemaTypes.Mixed]
+}, {
+    collection: 'aggregateOffers',
+    id: true,
+    read: 'primaryPreferred',
+    writeConcern: writeConcern_1.writeConcern,
+    strict: true,
+    strictQuery: false,
+    timestamps: {
+        createdAt: 'createdAt',
+        updatedAt: 'updatedAt'
+    },
+    toJSON: {
+        getters: false,
+        virtuals: false,
+        minimize: false,
+        versionKey: false
+    },
+    toObject: {
+        getters: false,
+        virtuals: true,
+        minimize: false,
+        versionKey: false
+    }
+});
+exports.schema = schema;
+schema.index({ createdAt: 1 }, { name: 'searchByCreatedAt' });
+schema.index({ updatedAt: 1 }, { name: 'searchByUpdatedAt' });
+schema.index({ 'offers.priceSpecification.price': 1 }, { name: 'searchByOffersPriceSpecificationPrice' });
+schema.index({ 'project.id': 1, 'offers.priceSpecification.price': 1 }, { name: 'searchByProjectId' });
+// オファーIDはグローバルユニーク
+schema.index({ 'offers.id': 1 }, {
+    name: 'uniqueOfferId',
+    unique: true
+});
+// オファーコードはプロジェクト内ユニーク
+schema.index({ 'offers.identifier': 1, 'project.id': 1 }, {
+    name: 'uniqueOfferIdentifier',
+    unique: true
+});
+schema.index({ 'offers.availability': 1, 'offers.priceSpecification.price': 1 }, { name: 'searchByOffersAvailability' });
+schema.index({ 'offers.itemOffered.typeOf': 1, 'offers.priceSpecification.price': 1 }, { name: 'searchByOffersItemOfferedTypeOf' });
+schema.index({ 'offers.identifier': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersIdentifier',
+    partialFilterExpression: {
+        'offers.identifier': { $exists: true }
+    }
+});
+schema.index({ 'offers.priceSpecification.referenceQuantity.value': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersPriceSpecificationReferenceQuantityValue',
+    partialFilterExpression: {
+        'offers.priceSpecification.referenceQuantity.value': { $exists: true }
+    }
+});
+schema.index({ 'offers.priceSpecification.accounting.accountsReceivable': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersPriceSpecificationAccountingAccountsReceivable',
+    partialFilterExpression: {
+        'offers.priceSpecification.accounting.accountsReceivable': { $exists: true }
+    }
+});
+schema.index({ 'offers.priceSpecification.accounting.operatingRevenue.codeValue': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersPriceSpecificationAccountingOperatingRevenueCodeValue',
+    partialFilterExpression: {
+        'offers.priceSpecification.accounting.operatingRevenue.codeValue': { $exists: true }
+    }
+});
+schema.index({ 'offers.priceSpecification.appliesToMovieTicket.serviceType': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersPriceSpecificationAppliesToMovieTicketServiceType',
+    partialFilterExpression: {
+        'offers.priceSpecification.appliesToMovieTicket.serviceType': { $exists: true }
+    }
+});
+schema.index({ 'offers.priceSpecification.appliesToMovieTicket.serviceOutput.typeOf': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersPriceSpecificationAppliesToMovieTicketServiceOutputTypeOf',
+    partialFilterExpression: {
+        'offers.priceSpecification.appliesToMovieTicket.serviceOutput.typeOf': { $exists: true }
+    }
+});
+schema.index({ 'offers.name.ja': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersNameJa',
+    partialFilterExpression: {
+        'offers.name.ja': { $exists: true }
+    }
+});
+schema.index({ 'offers.name.en': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersNameEn',
+    partialFilterExpression: {
+        'offers.name.en': { $exists: true }
+    }
+});
+schema.index({ 'offers.alternateName': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersAlternateName',
+    partialFilterExpression: {
+        'offers.alternateName': { $exists: true }
+    }
+});
+schema.index({ 'offers.category.id': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchOffersCategoryId',
+    partialFilterExpression: {
+        'offers.category.id': { $exists: true }
+    }
+});
+schema.index({ 'offers.category.codeValue': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersCategoryCodeValue',
+    partialFilterExpression: {
+        'offers.category.codeValue': { $exists: true }
+    }
+});
+schema.index({ 'offers.availableAtOrFrom.id': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersAvailableAtOrFromId',
+    partialFilterExpression: {
+        'offers.availableAtOrFrom.id': { $exists: true }
+    }
+});
+schema.index({ 'offers.eligibleMembershipType.codeValue': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersEligibleMembershipTypeCodeValue',
+    partialFilterExpression: {
+        'offers.eligibleMembershipType.codeValue': { $exists: true }
+    }
+});
+schema.index({ 'offers.eligibleMonetaryAmount.currency': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersEligibleMonetaryAmountCurrency',
+    partialFilterExpression: {
+        'offers.eligibleMonetaryAmount.currency': { $exists: true }
+    }
+});
+schema.index({ 'offers.eligibleSeatingType.codeValue': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersEligibleSeatingTypeCodeValue',
+    partialFilterExpression: {
+        'offers.eligibleSeatingType.codeValue': { $exists: true }
+    }
+});
+schema.index({ 'offers.addOn.itemOffered.id': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersAddOnItemOfferedId',
+    partialFilterExpression: {
+        'offers.addOn.itemOffered.id': { $exists: true }
+    }
+});
+schema.index({ 'offers.hasMerchantReturnPolicy.id': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersHasMerchantReturnPolicyId',
+    partialFilterExpression: {
+        'offers.hasMerchantReturnPolicy.id': { $exists: true }
+    }
+});
+schema.index({ 'offers.additionalProperty': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersAdditionalProperty',
+    partialFilterExpression: {
+        'offers.additionalProperty': { $exists: true }
+    }
+});
+schema.index({ 'offers.validFrom': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersValidFrom',
+    partialFilterExpression: {
+        'offers.validFrom': { $exists: true }
+    }
+});
+schema.index({ 'offers.validThrough': 1, 'offers.priceSpecification.price': 1 }, {
+    name: 'searchByOffersValidThrough',
+    partialFilterExpression: {
+        'offers.validThrough': { $exists: true }
+    }
+});

package/lib/chevre/repo/mongoose/schemas/offer.js

@@ -29,6 +29,7 @@ const schema = new mongoose_1.Schema({
     availableAtOrFrom: [mongoose_1.SchemaTypes.Mixed],
     hasMerchantReturnPolicy: mongoose_1.SchemaTypes.Mixed,
     itemOffered: mongoose_1.SchemaTypes.Mixed,
+    // offers: [SchemaTypes.Mixed],
     priceCurrency: String,
     priceSpecification: mongoose_1.SchemaTypes.Mixed,
     eligibleCustomerType: mongoose_1.SchemaTypes.Mixed,

package/lib/chevre/repo/mongoose/schemas/order.d.ts

@@ -72,6 +72,7 @@ declare const schema: Schema<any, import("mongoose").Model<any, any, any, any, a
     customer?: any;
     returner?: any;
     orderStatus?: string | undefined;
+    previousOrderStatus?: string | undefined;
     isGift?: boolean | undefined;
     dateReturned?: Date | undefined;
 }, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
@@ -95,6 +96,7 @@ declare const schema: Schema<any, import("mongoose").Model<any, any, any, any, a
     customer?: any;
     returner?: any;
     orderStatus?: string | undefined;
+    previousOrderStatus?: string | undefined;
     isGift?: boolean | undefined;
     dateReturned?: Date | undefined;
 }>> & Omit<import("mongoose").FlatRecord<{
@@ -118,6 +120,7 @@ declare const schema: Schema<any, import("mongoose").Model<any, any, any, any, a
     customer?: any;
     returner?: any;
     orderStatus?: string | undefined;
+    previousOrderStatus?: string | undefined;
     isGift?: boolean | undefined;
     dateReturned?: Date | undefined;
 }> & {

package/lib/chevre/repo/mongoose/schemas/order.js

@@ -29,6 +29,7 @@ const schema = new mongoose_1.Schema({
     discounts: [mongoose_1.SchemaTypes.Mixed],
     url: String,
     orderStatus: String,
+    previousOrderStatus: String,
     orderDate: Date,
     isGift: Boolean,
     dateReturned: Date,

package/lib/chevre/repo/mongoose/schemas/task.d.ts

@@ -57,6 +57,7 @@ declare const schema: Schema<any, import("mongoose").Model<any, any, any, any, a
     status?: string | undefined;
     data?: any;
     project?: any;
+    identifier?: string | undefined;
     runsAt?: Date | undefined;
     remainingNumberOfTries?: number | undefined;
     lastTriedAt?: Date | undefined;
@@ -69,6 +70,7 @@ declare const schema: Schema<any, import("mongoose").Model<any, any, any, any, a
     status?: string | undefined;
     data?: any;
     project?: any;
+    identifier?: string | undefined;
     runsAt?: Date | undefined;
     remainingNumberOfTries?: number | undefined;
     lastTriedAt?: Date | undefined;
@@ -81,6 +83,7 @@ declare const schema: Schema<any, import("mongoose").Model<any, any, any, any, a
     status?: string | undefined;
     data?: any;
     project?: any;
+    identifier?: string | undefined;
     runsAt?: Date | undefined;
     remainingNumberOfTries?: number | undefined;
     lastTriedAt?: Date | undefined;

package/lib/chevre/repo/mongoose/schemas/task.js

@@ -9,6 +9,7 @@ exports.modelName = modelName;
  * タスクスキーマ
  */
 const schema = new mongoose_1.Schema({
+    identifier: String,
     project: mongoose_1.SchemaTypes.Mixed,
     name: String,
     status: String,
@@ -52,6 +53,13 @@ schema.index({ 'project.id': 1, runsAt: -1 }, { name: 'searchByProjectId-v202207
 schema.index({ name: 1, runsAt: -1 }, { name: 'searchByName-v2' });
 schema.index({ status: 1, runsAt: -1 }, { name: 'searchByStatus-v2' });
 schema.index({ runsAt: -1 }, { name: 'searchByRunsAt-v2' });
+// identifier追加(2023-09-01~)
+schema.index({ identifier: 1, runsAt: -1 }, {
+    name: 'searchByIdentifier',
+    partialFilterExpression: {
+        identifier: { $exists: true }
+    }
+});
 schema.index({ dateAborted: 1, runsAt: -1 }, {
     name: 'searchByDateAborted',
     partialFilterExpression: {

package/lib/chevre/repo/offer.d.ts

@@ -22,19 +22,28 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-import { Connection } from 'mongoose';
+import { BulkWriteResult as BulkWriteOpResultObject } from 'mongodb';
+import { AnyExpression, Connection, PipelineStage } from 'mongoose';
 import * as factory from '../factory';
-interface IProjection {
-    [key: string]: 0 | 1;
-}
+type IMatchStage = PipelineStage.Match;
+type KeyOfUnitPriceOffer = keyof factory.unitPriceOffer.IUnitPriceOffer;
+type IProjection = {
+    [key in KeyOfUnitPriceOffer]?: 0 | 1;
+};
 /**
  * オファーリポジトリ
  */
 export declare class MongoRepository {
+    private readonly aggregateOfferModel;
     private readonly offerModel;
     private readonly offerCatalogModel;
+    private readonly taskModel;
     constructor(connection: Connection);
     static CREATE_OFFER_MONGO_CONDITIONS(params: factory.unitPriceOffer.ISearchConditions): any[];
+    static CREATE_AGGREGATE_OFFERS_MATCH_CONDITIONS(params: factory.unitPriceOffer.ISearchConditions): IMatchStage[];
+    static CREATE_AGGREGATE_OFFERS_PROJECTION(params: IProjection): {
+        [field: string]: AnyExpression;
+    };
     /**
      * カタログに含まれるオファーを検索する
      * カタログに登録されたオファーの順序は保証される
@@ -55,18 +64,37 @@ export declare class MongoRepository {
         onlyValid?: boolean;
         limit?: number;
         page?: number;
-        sort: boolean;
         projection?: IProjection;
+        /**
+         * 強制的にoffersコレクションを使用する
+         */
+        useOffersAsPrimary?: boolean;
     }): Promise<{
         offers: factory.unitPriceOffer.IUnitPriceOffer[];
         sortedOfferIds: string[];
     }>;
     findById(params: {
+        project: {
+            id: string;
+        };
         id: string;
     }): Promise<factory.unitPriceOffer.IUnitPriceOffer>;
-    count(params: factory.unitPriceOffer.ISearchConditions): Promise<number>;
-    search(params: factory.unitPriceOffer.ISearchConditions, projection?: IProjection): Promise<factory.unitPriceOffer.IUnitPriceOffer[]>;
+    findAggregateOfferById(params: {
+        project: {
+            id: string;
+        };
+        id: string;
+    }): Promise<factory.aggregateOffer.IAggregateOffer>;
+    count(params: Omit<factory.unitPriceOffer.ISearchConditions, 'limit' | 'page' | 'sort'>): Promise<number>;
+    search(params: factory.unitPriceOffer.ISearchConditions, projection?: IProjection, 
+    /**
+     * 強制的にoffersコレクションを使用する
+     */
+    useOffersAsPrimary?: boolean): Promise<factory.unitPriceOffer.IUnitPriceOffer[]>;
     save(params: factory.unitPriceOffer.IUnitPriceOffer): Promise<factory.unitPriceOffer.IUnitPriceOffer>;
+    /**
+     * sskts専用オファー保管
+     */
     saveManyByIdentifier(params: {
         attributes: factory.unitPriceOffer.IUnitPriceOffer;
         upsert?: boolean;
@@ -87,17 +115,46 @@ export declare class MongoRepository {
         };
     }): Promise<import("mongodb").UpdateResult | undefined>;
     deleteById(params: {
-        id: string;
-    }): Promise<void>;
-    deleteByProject(params: {
         project: {
             id: string;
         };
+        id: string;
     }): Promise<void>;
     getCursor(conditions: any, projection: any): import("mongoose").Cursor<any, import("mongoose").QueryOptions<any>>;
-    unsetUnnecessaryFields(params: {
-        filter: any;
-        $unset: any;
-    }): Promise<import("mongodb").UpdateResult>;
+    sync2aggregateOffer(params: {
+        id?: {
+            $in: string[];
+        };
+        identifier?: {
+            $in: string[];
+        };
+        project: {
+            id: string;
+        };
+        isDeleted: boolean;
+        typeOf: factory.offerType.AggregateOffer | factory.offerType.Offer;
+    }): Promise<BulkWriteOpResultObject | void>;
+    /**
+     * オファー同期専用のタスク保管
+     */
+    saveSyncTask(params: {
+        id: {
+            $in: string[];
+        };
+        identifier: {
+            $in: string[];
+        };
+        isDeleted: boolean;
+        project: {
+            id: string;
+        };
+        typeOf: factory.offerType.AggregateOffer | factory.offerType.Offer;
+        options: {
+            emitImmediately: boolean;
+        };
+    }): Promise<{
+        id: string;
+    }[]>;
+    private searchFromAggregateOffer;
 }
 export {};