@chevre/domain 23.2.0-alpha.6 → 23.2.0-alpha.60

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

@@ -8,7 +8,7 @@ const settings_1 = require("../../../settings");
 const modelName = 'OfferCatalog';
 exports.modelName = modelName;
 const schemaDefinition = {
-    project: mongoose_1.SchemaTypes.Mixed,
+    project: { type: mongoose_1.SchemaTypes.Mixed, required: true },
     _id: String,
     identifier: {
         type: String,
@@ -22,7 +22,7 @@ const schemaDefinition = {
         required: true
     },
     itemListElement: [mongoose_1.SchemaTypes.Mixed],
-    itemOffered: mongoose_1.SchemaTypes.Mixed,
+    itemOffered: { type: mongoose_1.SchemaTypes.Mixed, required: true },
     additionalProperty: [mongoose_1.SchemaTypes.Mixed],
     dateSynced: Date // 追加(2023-09-13~)
     // createdAt: SchemaTypes.Mixed,
@@ -60,12 +60,6 @@ const indexes = [
             name: 'searchByIdentifier'
         }
     ],
-    [
-        { 'project.id': 1, identifier: 1 },
-        {
-            name: 'searchByProjectId-v20220721'
-        }
-    ],
     [
         { 'itemListElement.typeOf': 1, identifier: 1 },
         {

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

@@ -8,7 +8,7 @@ const settings_1 = require("../../../settings");
 const modelName = 'OfferCatalogItem';
 exports.modelName = modelName;
 const schemaDefinition = {
-    project: mongoose_1.SchemaTypes.Mixed,
+    project: { type: mongoose_1.SchemaTypes.Mixed, required: true },
     identifier: {
         type: String,
         required: true
@@ -21,7 +21,7 @@ const schemaDefinition = {
         required: true
     },
     itemListElement: [mongoose_1.SchemaTypes.Mixed],
-    itemOffered: mongoose_1.SchemaTypes.Mixed,
+    itemOffered: { type: mongoose_1.SchemaTypes.Mixed, required: true },
     additionalProperty: [mongoose_1.SchemaTypes.Mixed],
     dateSynced: Date,
     relatedOffer: mongoose_1.SchemaTypes.Mixed
@@ -61,6 +61,32 @@ const indexes = [
             unique: true,
             name: 'uniqueIdentifier'
         }
+    ],
+    [
+        { identifier: 1 },
+        { name: 'identifier' }
+    ],
+    [
+        { 'itemOffered.typeOf': 1, identifier: 1 },
+        { name: 'itemOfferedTypeOf' }
+    ],
+    [
+        { 'itemListElement.typeOf': 1, identifier: 1 },
+        {
+            name: 'itemListElementTypeOf',
+            partialFilterExpression: {
+                'itemListElement.typeOf': { $exists: true }
+            }
+        }
+    ],
+    [
+        { 'itemListElement.id': 1, identifier: 1 },
+        {
+            name: 'itemListElementId',
+            partialFilterExpression: {
+                'itemListElement.id': { $exists: true }
+            }
+        }
     ]
 ];
 exports.indexes = indexes;

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

@@ -1,9 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.place.screeningRoom.IPlace & {
+type ISeatSection = Pick<factory.place.screeningRoomSection.IPlace, 'additionalProperty' | 'branchCode' | 'name' | 'typeOf'> & {
+    containsPlace?: factory.place.seat.IPlace[];
+};
+type IDocType = Omit<factory.place.screeningRoom.IPlace, 'containsPlace'> & {
     description?: any;
     openingHoursSpecification?: any;
     smokingAllowed?: boolean;
+    containsPlace: ISeatSection[];
 };
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
@@ -11,4 +15,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "Place";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -110,6 +110,43 @@ export interface IJWTSetting {
      */
     algorithm: Algorithm;
 }
+export interface IOrderNumberSetting {
+    validFrom: Date;
+    /**
+     * fpe暗号鍵
+     */
+    fpeSecret: string;
+    /**
+     * "A"
+     */
+    version: string;
+    versioningForceProjects?: string[];
+    /**
+     * 強制的にバージョニング不使用のプロジェクト
+     */
+    versioningExceptionProjects?: string[];
+}
+export interface ITransactionNumberSetting {
+    validFrom: Date;
+    /**
+     * fpe暗号鍵
+     */
+    fpeSecret: string;
+    /**
+     * "1"
+     */
+    version: string;
+}
+export interface IServiceOutputIdentifierSetting {
+    /**
+     * fpe暗号鍵
+     */
+    fpeSecret: string;
+    /**
+     * "1"
+     */
+    version: string;
+}
 export interface ISetting {
     defaultSenderEmail?: string;
     jwt?: IJWTSetting;
@@ -121,12 +158,15 @@ export interface ISetting {
         informResource?: factory.project.IInformParams[];
     };
     onTransactionStatusChanged?: IOnTransactionStatusChanged;
+    orderNumber?: IOrderNumberSetting;
     project: {
         id: string;
         typeOf: factory.organizationType.Project;
     };
     quota?: IQuotaSettings;
+    serviceOutputIdentifier?: IServiceOutputIdentifierSetting;
     storage?: IStorageSettings;
+    transactionNumber?: ITransactionNumberSetting;
     /**
      * 通知設定
      */

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

@@ -17,8 +17,11 @@ const schemaDefinition = {
     onTaskStatusChanged: mongoose_1.SchemaTypes.Mixed,
     onResourceUpdated: mongoose_1.SchemaTypes.Mixed,
     onTransactionStatusChanged: mongoose_1.SchemaTypes.Mixed,
+    orderNumber: mongoose_1.SchemaTypes.Mixed,
     quota: mongoose_1.SchemaTypes.Mixed,
+    serviceOutputIdentifier: mongoose_1.SchemaTypes.Mixed,
     storage: mongoose_1.SchemaTypes.Mixed,
+    transactionNumber: mongoose_1.SchemaTypes.Mixed,
     triggerWebhook: mongoose_1.SchemaTypes.Mixed,
     useInformResourceTypes: [String],
     userPoolIdOld: String,

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

@@ -35,7 +35,20 @@ export declare class OfferCatalogRepo {
         $unset?: {
             [key in keyof factory.offerCatalog.IOfferCatalog]?: 1;
         };
-    }[]): Promise<{
+    }[], options: {
+        /**
+         * support only update(2026-01-30~)
+         */
+        update: boolean;
+        /**
+         * プロダクトタイプでfilter(2026-01-30~)
+         */
+        productType: factory.product.ProductType;
+        /**
+         * アイテムタイプでfilter(2026-02-03~)
+         */
+        itemListElementType: factory.offerCatalog.IItemListElement['typeOf'];
+    }): Promise<{
         bulkWriteResult: BulkWriteResult;
         modifiedCatalogs: {
             id: string;

package/lib/chevre/repo/offerCatalog.js

@@ -195,11 +195,9 @@ class OfferCatalogRepo {
     /**
      * コードをキーにして冪等置換(2023-12-14~)
      */
-    upsertManyByIdentifier(params
-    // options?: {
-    // }
-    ) {
+    upsertManyByIdentifier(params, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { itemListElementType, productType, update } = options;
             const uniqid = yield Promise.resolve().then(() => require('uniqid'));
             const bulkWriteOps = [];
             const queryFilters = [];
@@ -209,28 +207,52 @@ class OfferCatalogRepo {
                     if (typeof identifier !== 'string' || identifier.length === 0) {
                         throw new factory.errors.ArgumentNull('identifier');
                     }
+                    // 指定されたproductTypeを強制する
+                    if (setFields.itemOffered.typeOf !== productType) {
+                        throw new factory.errors.Argument('itemOffered.typeOf', `not matched with productType: ${productType}`);
+                    }
+                    // 指定されたitemListElementTypeを強制する
+                    const everyElementTypeMatched = setFields.itemListElement.every((element) => element.typeOf === itemListElementType);
+                    if (!everyElementTypeMatched) {
+                        throw new factory.errors.Argument('itemListElement.typeOf', `not matched with itemListElementType: ${itemListElementType}`);
+                    }
                     // リソースのユニークネスを保証するfilter
                     const filter = {
                         'project.id': { $eq: project.id },
-                        identifier: { $eq: identifier }
+                        identifier: { $eq: identifier },
+                        'itemOffered.typeOf': { $exists: true, $eq: productType }, // プロダクトタイプを変更させないためにフィルター追加(2026-01-30~)
+                        'itemListElement.typeOf': { $exists: true, $eq: itemListElementType } // アイテムタイプを変更させないためにフィルター追加(2026-02-03~)
                     };
                     queryFilters.push({
                         'project.id': { $eq: project.id },
-                        identifier: { $eq: identifier }
+                        identifier: { $eq: identifier },
+                        'itemOffered.typeOf': { $exists: true, $eq: productType }, // プロダクトタイプを変更させないためにフィルター追加(2026-01-30~)
+                        'itemListElement.typeOf': { $exists: true, $eq: itemListElementType } // アイテムタイプを変更させないためにフィルター追加(2026-02-03~)
                     });
-                    const newId = uniqid();
-                    const setOnInsert = {
-                        identifier,
-                        project,
-                        typeOf,
-                        _id: newId
-                    };
-                    const updateOne = {
-                        filter,
-                        update: Object.assign({ $setOnInsert: setOnInsert, $set: setFields }, ($unset !== undefined) ? { $unset } : undefined),
-                        upsert: true
-                    };
-                    bulkWriteOps.push({ updateOne });
+                    if (update === true) {
+                        const updateOne = {
+                            filter,
+                            update: Object.assign({ $set: setFields }, ($unset !== undefined) ? { $unset } : undefined),
+                            upsert: false
+                        };
+                        bulkWriteOps.push({ updateOne });
+                    }
+                    else {
+                        // デフォルトはupsert操作
+                        const newId = uniqid();
+                        const setOnInsert = {
+                            identifier,
+                            project,
+                            typeOf,
+                            _id: newId
+                        };
+                        const updateOne = {
+                            filter,
+                            update: Object.assign({ $setOnInsert: setOnInsert, $set: setFields }, ($unset !== undefined) ? { $unset } : undefined),
+                            upsert: true
+                        };
+                        bulkWriteOps.push({ updateOne });
+                    }
                 });
             }
             if (bulkWriteOps.length > 0) {

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

@@ -32,7 +32,16 @@ export declare class OfferCatalogItemRepo {
         $unset?: {
             [key in keyof factory.offerCatalog.IOfferCatalog]?: 1;
         };
-    }[]): Promise<{
+    }[], options: {
+        /**
+         * support only update(2026-01-30~)
+         */
+        update: boolean;
+        /**
+         * プロダクトタイプでfilter(2026-01-30~)
+         */
+        productType: factory.product.ProductType;
+    }): Promise<{
         bulkWriteResult: BulkWriteResult;
         modifiedCatalogs: {
             id: string;

package/lib/chevre/repo/offerCatalogItem.js

@@ -159,11 +159,9 @@ class OfferCatalogItemRepo {
     /**
      * コードをキーにして冪等置換(2023-12-14~)
      */
-    upsertManyByIdentifier(params
-    // options?: {
-    // }
-    ) {
+    upsertManyByIdentifier(params, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { productType, update } = options;
             const bulkWriteOps = [];
             const queryFilters = [];
             if (Array.isArray(params)) {
@@ -172,26 +170,43 @@ class OfferCatalogItemRepo {
                     if (typeof identifier !== 'string' || identifier.length === 0) {
                         throw new factory.errors.ArgumentNull('identifier');
                     }
+                    // 指定されたproductTypeを強制する
+                    if (setFields.itemOffered.typeOf !== productType) {
+                        throw new factory.errors.Argument('itemOffered.typeOf', `not matched with productType: ${productType}`);
+                    }
                     // リソースのユニークネスを保証するfilter
                     const filter = {
                         'project.id': { $eq: project.id },
-                        identifier: { $eq: identifier }
+                        identifier: { $eq: identifier },
+                        'itemOffered.typeOf': { $exists: true, $eq: productType } // プロダクトタイプを変更させないためにフィルター追加(2026-01-30~)
                     };
                     queryFilters.push({
                         'project.id': { $eq: project.id },
-                        identifier: { $eq: identifier }
+                        identifier: { $eq: identifier },
+                        'itemOffered.typeOf': { $exists: true, $eq: productType } // プロダクトタイプを変更させないためにフィルター追加(2026-01-30~)
                     });
-                    const setOnInsert = {
-                        identifier,
-                        project,
-                        typeOf
-                    };
-                    const updateOne = {
-                        filter,
-                        update: Object.assign({ $setOnInsert: setOnInsert, $set: setFields }, ($unset !== undefined) ? { $unset } : undefined),
-                        upsert: true
-                    };
-                    bulkWriteOps.push({ updateOne });
+                    if (update === true) {
+                        const updateOne = {
+                            filter,
+                            update: Object.assign({ $set: setFields }, ($unset !== undefined) ? { $unset } : undefined),
+                            upsert: false
+                        };
+                        bulkWriteOps.push({ updateOne });
+                    }
+                    else {
+                        // デフォルトはupsert操作
+                        const setOnInsert = {
+                            identifier,
+                            project,
+                            typeOf
+                        };
+                        const updateOne = {
+                            filter,
+                            update: Object.assign({ $setOnInsert: setOnInsert, $set: setFields }, ($unset !== undefined) ? { $unset } : undefined),
+                            upsert: true
+                        };
+                        bulkWriteOps.push({ updateOne });
+                    }
                 });
             }
             if (bulkWriteOps.length > 0) {

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

@@ -4,9 +4,11 @@ import type { Connection } from 'mongoose';
  */
 export declare class OrderNumberRepo {
     private readonly counterRepo;
+    private readonly settingModel;
     constructor(params: {
         connection: Connection;
     });
+    static GENERATE_VERSION0(timestamp: string, seq: number): string;
     /**
      * タイムスタンプから発行する
      */
@@ -19,4 +21,9 @@ export declare class OrderNumberRepo {
          */
         orderDate: Date;
     }): Promise<string>;
+    decrypt(id: string): Promise<string>;
+    /**
+     * 注文番号生成設定を検索する
+     */
+    private findSetting;
 }

package/lib/chevre/repo/orderNumber.js

@@ -12,39 +12,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrderNumberRepo = void 0;
 const cdigit = require("cdigit");
 const moment = require("moment-timezone");
-// import { RedisClientType } from 'redis';
 // tslint:disable-next-line:no-require-imports no-var-requires
-const fpe = require('node-fpe');
-// import { createSchema as createSettingSchema, modelName as settingModelName } from './mongoose/schemas/setting';
-const transactionNumber_1 = require("./mongoose/schemas/transactionNumber");
+const fpe = require('node-fpe-v1');
+const factory = require("../factory");
+const transactionNumber_1 = require("../factory/transactionNumber");
+const setting_1 = require("./mongoose/schemas/setting");
+const transactionNumber_2 = require("./mongoose/schemas/transactionNumber");
 const transactionNumberCounter_1 = require("./transactionNumberCounter");
 const ORDER_NUMBER_SEPARATOR = '-';
+const defaultVersioningForceProjects = [
+    'HMX',
+    'SMT',
+    'KOJ'
+];
 /**
  * 注文番号リポジトリ
  */
 class OrderNumberRepo {
     constructor(params) {
-        // const { connection } = params;
-        // this.settingModel = connection.model(settingModelName, createSettingSchema());
         this.counterRepo = new transactionNumberCounter_1.TransactionNumberCounterRepo(params);
+        this.settingModel = params.connection.model(setting_1.modelName, (0, setting_1.createSchema)());
+    }
+    static GENERATE_VERSION0(timestamp, seq) {
+        let orderNumber = `${timestamp}${seq}`;
+        // checkdigit
+        const cd = cdigit.luhn.compute(orderNumber);
+        orderNumber = fpe({ password: cd })
+            .encrypt(orderNumber);
+        orderNumber = `${cd}${orderNumber}`;
+        return orderNumber;
     }
-    // private static createKey(params: {
-    //     orderDate: Date;
-    //     projectPrefix: string;
-    //     timestamp: string;
-    // }): string {
-    //     return util.format(
-    //         '%s:%s:%s',
-    //         OrderNumberRepo.REDIS_KEY_PREFIX,
-    //         params.projectPrefix,
-    //         params.timestamp
-    //     );
-    // }
     /**
      * タイムスタンプから発行する
      */
     publishByTimestamp(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { fpeSecret, version, validFrom, versioningForceProjects, versioningExceptionProjects } = yield this.findSetting();
             const timestamp = moment(params.orderDate)
                 .valueOf()
                 .toString();
@@ -53,31 +56,104 @@ class OrderNumberRepo {
             let dataFeedExpires;
             const dataFeedIdentifier = `${projectPrefix}:${timestamp}`;
             let incrReply;
-            // const useMongoBySettings = await this.useMongoBySettings(params);
             dataFeedExpires = moment(params.orderDate)
                 .add(1, 'minute') // ミリ秒でカウントしていくので、注文日時後1分で十分
                 .toDate();
             incrReply = yield this.counterRepo.incrementByMongo({
                 identifier: dataFeedIdentifier,
-                includedInDataCatalog: { identifier: transactionNumber_1.DataCatalogIdentifier.orderNumber },
+                includedInDataCatalog: { identifier: transactionNumber_2.DataCatalogIdentifier.orderNumber },
                 expires: dataFeedExpires
             });
-            let orderNumber = `${timestamp}${incrReply}`;
-            // checkdigit
-            const cd = cdigit.luhn.compute(orderNumber);
-            orderNumber = fpe({ password: cd })
-                .encrypt(orderNumber);
-            orderNumber = `${projectPrefix}${cd}${orderNumber}`;
-            orderNumber = `${[
-                // tslint:disable-next-line:no-magic-numbers
-                orderNumber.slice(0, 4),
-                // tslint:disable-next-line:no-magic-numbers
-                orderNumber.slice(4, 11),
-                // tslint:disable-next-line:no-magic-numbers
-                orderNumber.slice(11)
-            ].join(ORDER_NUMBER_SEPARATOR)}`;
+            let orderNumber;
+            let useVersioning = (validFrom instanceof Date && moment(validFrom)
+                .isSameOrBefore(params.orderDate))
+                // versioningForceProjectsであれば強制的にversioning(2026-02-05~)
+                || versioningForceProjects.includes(projectPrefix);
+            // versioningExceptionProjectsであれば強制的にversioning不使用(2026-02-10~)
+            if (versioningExceptionProjects.includes(projectPrefix)) {
+                useVersioning = false;
+            }
+            if (typeof fpeSecret === 'string' && typeof version === 'string' && useVersioning) {
+                const transactionFactory = new transactionNumber_1.TransactionNumberFactory({ fpeSecret, version });
+                orderNumber = transactionFactory.generate(timestamp, incrReply);
+                orderNumber = `${projectPrefix.at(0)}${orderNumber}`; // 桁数をversion0に合わせるためにエイリアスの1文字目のみを採用
+                orderNumber = `${[
+                    // tslint:disable-next-line:no-magic-numbers
+                    orderNumber.slice(0, 4),
+                    // tslint:disable-next-line:no-magic-numbers
+                    orderNumber.slice(4, 11),
+                    // tslint:disable-next-line:no-magic-numbers
+                    orderNumber.slice(11)
+                ].join(ORDER_NUMBER_SEPARATOR)}`;
+            }
+            else {
+                orderNumber = OrderNumberRepo.GENERATE_VERSION0(timestamp, incrReply);
+                orderNumber = `${projectPrefix}${orderNumber}`;
+                orderNumber = `${[
+                    // tslint:disable-next-line:no-magic-numbers
+                    orderNumber.slice(0, 4),
+                    // tslint:disable-next-line:no-magic-numbers
+                    orderNumber.slice(4, 11),
+                    // tslint:disable-next-line:no-magic-numbers
+                    orderNumber.slice(11)
+                ].join(ORDER_NUMBER_SEPARATOR)}`;
+            }
             return orderNumber;
         });
     }
+    decrypt(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { fpeSecret, version } = yield this.findSetting();
+            if (typeof fpeSecret === 'string' && typeof version === 'string') {
+                const transactionFactory = new transactionNumber_1.TransactionNumberFactory({ fpeSecret, version });
+                const originalOrderNumber = id.replace(/-/g, '')
+                    // tslint:disable-next-line:no-magic-numbers
+                    .slice(1);
+                return transactionFactory.decrypt(originalOrderNumber);
+            }
+            else {
+                throw new factory.errors.NotImplemented('no version not implemented');
+            }
+        });
+    }
+    /**
+     * 注文番号生成設定を検索する
+     */
+    findSetting() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filterQuery = { 'project.id': { $eq: '*' } };
+            const projection = {
+                _id: 0,
+                orderNumber: 1
+            };
+            const setting = yield this.settingModel.findOne(filterQuery, projection)
+                .lean()
+                .exec();
+            if (setting === null || setting.orderNumber === undefined) {
+                return {
+                    versioningForceProjects: [],
+                    versioningExceptionProjects: []
+                };
+            }
+            const { fpeSecret, version, validFrom, versioningForceProjects, versioningExceptionProjects } = setting.orderNumber;
+            if (typeof fpeSecret !== 'string' || fpeSecret === '') {
+                throw new factory.errors.NotFound('setting.orderNumber.secret');
+            }
+            if (typeof version !== 'string' || version === '') {
+                throw new factory.errors.NotFound('setting.orderNumber.version');
+            }
+            if (!(validFrom instanceof Date)) {
+                throw new factory.errors.NotFound('setting.orderNumber.validFrom must be Date');
+            }
+            return {
+                fpeSecret, version, validFrom,
+                versioningForceProjects: [
+                    ...(Array.isArray(versioningForceProjects)) ? versioningForceProjects : [],
+                    ...defaultVersioningForceProjects
+                ],
+                versioningExceptionProjects: (Array.isArray(versioningExceptionProjects)) ? versioningExceptionProjects : []
+            };
+        });
+    }
 }
 exports.OrderNumberRepo = OrderNumberRepo;

package/lib/chevre/repo/place/entranceGate.d.ts

@@ -0,0 +1,57 @@
+import type { BulkWriteResult } from 'mongodb';
+import { Connection } from 'mongoose';
+import * as factory from '../../factory';
+/**
+ * ゲートを操作する組織
+ */
+interface IOperator {
+    /**
+     * 施設ID
+     */
+    id: string;
+}
+type IEntranceGate = Pick<factory.place.entranceGate.IEntranceGate, 'identifier' | 'name'>;
+type ICreatingEntranceGate = Pick<factory.place.entranceGate.IEntranceGate, 'identifier' | 'name'>;
+interface IUpdateOptions {
+    project: {
+        id: string;
+    };
+}
+/**
+ * 施設の入場ゲートリポジトリ
+ */
+export declare class EntranceGateRepo {
+    /**
+     * 施設
+     */
+    private readonly operator;
+    private readonly civicStructureModel;
+    constructor(connection: Connection, operater: IOperator);
+    /**
+     * リポジトリの施設をセットする
+     */
+    setOperatorId(params: {
+        id: string;
+    }): void;
+    findEntranceGates(params: factory.place.entranceGate.ISearchConditions): Promise<IEntranceGate[]>;
+    addEntranceGatesByIdentifierIfNotExist(params: {
+        $set: ICreatingEntranceGate;
+    }[], options: IUpdateOptions): Promise<{
+        bulkWriteResult?: BulkWriteResult;
+    }>;
+    updateEntranceGatesByIdentifier(params: {
+        $set: ICreatingEntranceGate;
+    }[], options: IUpdateOptions): Promise<{
+        bulkWriteResult?: BulkWriteResult;
+    }>;
+    deleteEntranceGatesByIdentifier(params: {
+        /**
+         * ゲートコード
+         */
+        identifier: string;
+    }[], options: IUpdateOptions): Promise<{
+        bulkWriteResult?: BulkWriteResult;
+    }>;
+    private createMatchStages;
+}
+export {};