@chevre/domain 24.0.0-alpha.28 → 24.0.0-alpha.29

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

@@ -1,13 +1,14 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.project.IProject, 'id'> & {
     _id: string;
     aggregateReservation?: any;
     makesOffer?: factory.project.IMakesOffer[];
 };
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Project";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,14 +1,15 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = (Omit<factory.reservation.IReservation<factory.reservationType.BusReservation>, 'id'> | Omit<factory.reservation.IReservation<factory.reservationType.EventReservation>, 'id'>) & {
     _id: string;
     bookingAgent?: any;
     previousReservationStatus?: factory.reservationStatusType;
 };
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Reservation";
 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/reserveInterface.d.ts

@@ -1,11 +1,12 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
+import { IVirtuals } from '../virtuals';
 export type IWebAPI = Omit<factory.service.webAPI.IServiceWithChannel, 'id'>;
 type IDocType = IWebAPI;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "ReserveInterface";
 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/role.d.ts

@@ -1,9 +1,10 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Pick<factory.role.organizationRole.IRole, 'permissions' | 'roleName' | 'typeOf' | 'member' | 'memberOf'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Role";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,10 +1,11 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.schedule.IEventWithSchedule, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Schedule";
 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/seller.d.ts

@@ -1,9 +1,10 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.seller.ISeller, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Seller";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,9 +1,10 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.sellerReturnPolicy.ISellerReturnPolicy, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "SellerReturnPolicy";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/schemas/service/availableHour.d.ts

@@ -1,4 +1,5 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../../virtuals';
 /**
  * The place is open if the opens property is specified, and closed otherwise.
  */
@@ -9,9 +10,9 @@ interface IOpeningHoursSpecification {
     validThrough: Date;
 }
 type IDocType = IOpeningHoursSpecification;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Service.AvailableHour";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,10 +1,11 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.permit.IPermit, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "ServiceOutput";
 declare function createSchema(): ISchema;
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,6 +1,7 @@
 import type { Algorithm } from 'jsonwebtoken';
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
+import { IVirtuals } from '../virtuals';
 interface IOnOrderStatusChanged {
     /**
      * AggService通知先
@@ -182,9 +183,9 @@ export interface ISetting {
     useMongo4transactionNumberFrom?: Date;
 }
 type IDocType = ISetting;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Setting";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,9 +1,10 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.task.ITask<factory.taskName>, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Task";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,9 +1,10 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 type IDocType = any;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Telemetry";
 declare function createSchema(): ISchema;
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,4 +1,5 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 export interface ITicketIssuedBy {
     id: string;
@@ -19,9 +20,9 @@ export interface ITicket {
     issuedBy: ITicketIssuedBy;
 }
 type IDocType = Omit<ITicket, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Ticket";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,12 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IPlaceOrder = Omit<factory.transaction.placeOrder.ITransaction, 'id'>;
 type IReturnOrder = Omit<factory.transaction.returnOrder.ITransaction, 'id'>;
 type IMoneyTransfer = Omit<factory.transaction.moneyTransfer.ITransaction, 'id'>;
 type IDocType = IPlaceOrder | IReturnOrder | IMoneyTransfer;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Transaction";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,4 +1,5 @@
 import { Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 declare enum DataCatalogIdentifier {
     confirmationNumber = "confirmationNumber",
@@ -31,9 +32,9 @@ interface IDataFeed {
     };
 }
 type IDocType = IDataFeed;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "TransactionNumber";
 declare function createSchema(): ISchema;
 export { createSchema, IDocType, IModel, modelName, DataCatalogIdentifier };

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

@@ -1,10 +1,11 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.trip.ITrip<factory.tripType>, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Trip";
 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/webSite.d.ts

@@ -1,9 +1,10 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.creativeWork.certification.webSite.ICertification, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "WebSite";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/virtuals.d.ts

@@ -0,0 +1,3 @@
+export interface IVirtuals {
+    id: string;
+}

package/lib/chevre/repo/mongoose/virtuals.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -169,7 +169,7 @@ export declare class OfferCatalogRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
         _id: string;
         alternateName?: any;
         dateSynced?: Date;
@@ -177,7 +177,7 @@ export declare class OfferCatalogRepo {
         _id: string;
     }> & {
         __v: number;
-    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
+    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
         _id: string;
         alternateName?: any;
         dateSynced?: Date;
@@ -185,7 +185,7 @@ export declare class OfferCatalogRepo {
         _id: string;
     }> & {
         __v: number;
-    }) | null>;
+    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.offerCatalog.IOfferCatalog>;
         $unset: any;

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

@@ -1,5 +1,6 @@
 import type { Connection, FilterQuery } from 'mongoose';
 import * as factory from '../factory';
+import { IDocType } from './mongoose/schemas/order';
 type IOrderWithoutAcceptedOffers = factory.order.IOrder;
 type IKeyOfProjection = Extract<keyof IOrderWithoutAcceptedOffers, 'broker' | 'confirmationNumber' | 'customer' | 'dateReturned' | 'identifier' | 'name' | 'orderDate' | 'orderNumber' | 'orderStatus' | 'orderedItem' | 'paymentMethods' | 'previousOrderStatus' | 'price' | 'priceCurrency' | 'project' | 'returner' | 'seller' | 'typeOf' | 'url'> | 'paymentMethods.accountId' | 'paymentMethods.name' | 'paymentMethods.paymentMethod' | 'paymentMethods.paymentMethodId' | 'paymentMethods.totalPaymentDue' | 'paymentMethods.additionalProperty' | 'paymentMethods.issuedThrough' | 'customer.id' | 'customer.typeOf';
 export type IReturnedOrder = Pick<IOrderWithoutAcceptedOffers, 'project' | 'typeOf' | 'orderNumber' | 'dateReturned' | 'id' | 'customer' | 'returner' | 'seller' | 'price' | 'priceCurrency' | 'orderDate'> & {
@@ -142,25 +143,19 @@ export declare class OrderRepo {
     }): Promise<(IOrderWithoutAcceptedOffers & {
         id: string;
     })[]>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, Omit<factory.order.IOrder, "id"> & {
-        acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
-    }, {}, {}> & Omit<factory.order.IOrder, "id"> & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.order.IOrder, "id"> & {
         acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
     } & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }, import("mongoose").QueryOptions<Omit<factory.order.IOrder, "id"> & {
-        acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
-    }>, (import("mongoose").Document<unknown, {}, Omit<factory.order.IOrder, "id"> & {
-        acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
-    }, {}, {}> & Omit<factory.order.IOrder, "id"> & {
+    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.order.IOrder, "id"> & {
         acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
     } & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }) | null>;
+    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.order.IOrder>;
         $unset: any;

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

@@ -74,19 +74,19 @@ export declare class OwnershipInfoRepo {
             $lt: Date;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood>, "id"> & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood>, "id"> & {
         _id: string;
     } & Required<{
         _id: string;
     }> & {
         __v: number;
-    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood>, "id"> & {
+    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood>, "id"> & {
         _id: string;
     } & Required<{
         _id: string;
     }> & {
         __v: number;
-    }) | null>;
+    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
     /**
      * 所有者を追加する
      */

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

@@ -1,6 +1,6 @@
 import type { Connection, FilterQuery } from 'mongoose';
 import * as factory from '../factory';
-import { IModel, IDocType } from './mongoose/schemas/paymentService';
+import { IModel } from './mongoose/schemas/paymentService';
 type IUnsetKey = keyof Pick<factory.service.paymentService.IService, 'additionalProperty' | 'availableChannel' | 'serviceOutput' | 'serviceType'>;
 type IKeyOfProjection4paymentService = keyof factory.service.paymentService.IService;
 /**
@@ -73,19 +73,6 @@ export declare class PaymentServiceRepo {
         filter: any;
         $unset: any;
     }): Promise<import("mongoose").UpdateWriteOpResult>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/service/paymentService").IService, "id"> & {
-        provider?: factory.service.paymentService.IProvider[];
-    } & {
-        _id: import("mongoose").Types.ObjectId;
-    } & {
-        __v: number;
-    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/service/paymentService").IService, "id"> & {
-        provider?: factory.service.paymentService.IProvider[];
-    } & {
-        _id: import("mongoose").Types.ObjectId;
-    } & {
-        __v: number;
-    }) | null>;
     getModel(): IModel;
 }
 export {};

package/lib/chevre/repo/paymentService.js

@@ -443,11 +443,11 @@ class PaymentServiceRepo {
         return this.paymentServiceModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
             .exec();
     }
-    getCursor(conditions, projection) {
-        return this.paymentServiceModel.find(conditions, projection)
-            .sort({ productID: factory.sortType.Ascending })
-            .cursor();
-    }
+    // public getCursor(conditions: any, projection: any) {
+    //     return this.paymentServiceModel.find(conditions, projection)
+    //         .sort({ productID: factory.sortType.Ascending })
+    //         .cursor();
+    // }
     getModel() {
         return this.paymentServiceModel;
     }

package/lib/chevre/repo/pendingReservation.js

@@ -40,7 +40,6 @@ class PendingReservationRepo {
     // private readonly aggregateReservationModel: IModel;
     pendingReservationModel;
     constructor(connection) {
-        // this.aggregateReservationModel = connection.model(modelName, createSchema());
         this.pendingReservationModel = connection.model(pendingReservation_1.modelName, (0, pendingReservation_1.createSchema)());
     }
     static CREATE_FILTER_QUERY(params) {

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

@@ -95,19 +95,19 @@ export declare class MovieTheaterRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/place/movieTheater").IPlace, "id"> & {
+    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("../mongoose/virtuals").IVirtuals, {}> & Omit<Omit<import("@chevre/factory/lib/place/movieTheater").IPlace, "id"> & {
         hasPOS?: factory.place.movieTheater.IPOS[];
     } & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/place/movieTheater").IPlace, "id"> & {
+    }, "id"> & import("../mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("../mongoose/virtuals").IVirtuals, {}> & Omit<Omit<import("@chevre/factory/lib/place/movieTheater").IPlace, "id"> & {
         hasPOS?: factory.place.movieTheater.IPOS[];
     } & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }) | null>;
+    }, "id"> & import("../mongoose/virtuals").IVirtuals) | null>;
     unsetUnnecessaryFields(params: {
         filter: any;
         $unset: any;

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

@@ -124,7 +124,7 @@ export declare class ScreeningRoomRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/place/screeningRoom").IPlace, "containsPlace"> & {
+    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("../mongoose/virtuals").IVirtuals, {}> & Omit<Omit<import("@chevre/factory/lib/place/screeningRoom").IPlace, "containsPlace"> & {
         description?: any;
         openingHoursSpecification?: any;
         smokingAllowed?: boolean;
@@ -135,7 +135,7 @@ export declare class ScreeningRoomRepo {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/place/screeningRoom").IPlace, "containsPlace"> & {
+    }, "id"> & import("../mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("../mongoose/virtuals").IVirtuals, {}> & Omit<Omit<import("@chevre/factory/lib/place/screeningRoom").IPlace, "containsPlace"> & {
         description?: any;
         openingHoursSpecification?: any;
         smokingAllowed?: boolean;
@@ -146,6 +146,6 @@ export declare class ScreeningRoomRepo {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }) | null>;
+    }, "id"> & import("../mongoose/virtuals").IVirtuals) | null>;
 }
 export {};

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

@@ -24,14 +24,14 @@ export declare class PotentialActionRepo {
         id: string;
     }>;
     projectFields(conditions: factory.potentialAction.ISearchConditions, inclusion: IKeyOfProjection[]): Promise<factory.potentialAction.IPotentialAction[]>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & IDocType & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<IDocType & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }, QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & IDocType & {
+    }, "id"> & import("./mongoose/virtuals").IVirtuals, QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<IDocType & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }) | null>;
+    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
 }
 export {};

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

@@ -13,13 +13,15 @@ export declare class PriceSpecificationRepo {
     findById<T extends factory.priceSpecificationType>(params: {
         id: string;
     }): Promise<factory.priceSpecification.IPriceSpecification<T>>;
-    save<T extends factory.priceSpecificationType>(params: {
+    save<T extends factory.priceSpecificationType.CategoryCodeChargeSpecification | factory.priceSpecificationType.MovieTicketTypeChargeSpecification>(params: {
         id?: string;
         attributes: factory.priceSpecification.IPriceSpecification<T> & {
             id?: never;
             $unset?: never;
         };
-    }): Promise<Pick<factory.priceSpecification.IPriceSpecification<T>, 'id'>>;
+    }): Promise<{
+        id: string;
+    }>;
     /**
      * 削除する
      */
@@ -34,7 +36,7 @@ export declare class PriceSpecificationRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & (({
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<({
         project?: Pick<factory.project.IProject, "id" | "typeOf"> | undefined;
         name?: (string | import("@chevre/factory/lib/multilingualString").IMultilingualString) | undefined;
         price: number;
@@ -67,7 +69,7 @@ export declare class PriceSpecificationRepo {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    })), import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & (({
+    }), "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<({
         project?: Pick<factory.project.IProject, "id" | "typeOf"> | undefined;
         name?: (string | import("@chevre/factory/lib/multilingualString").IMultilingualString) | undefined;
         price: number;
@@ -100,7 +102,7 @@ export declare class PriceSpecificationRepo {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }))) | null>;
+    }), "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
     unsetUnnecessaryFields(params: {
         filter: any;
         $unset: any;

package/lib/chevre/repo/priceSpecification.js

@@ -220,24 +220,26 @@ class PriceSpecificationRepo {
         return doc;
     }
     async save(params) {
-        let doc;
+        let savedId;
         if (typeof params.id !== 'string') {
             const { $unset, id, ...creatingDoc } = params.attributes;
-            doc = await this.priceSpecificationModel.create(creatingDoc);
+            const createdDoc = await this.priceSpecificationModel.create(creatingDoc);
+            savedId = createdDoc.id;
         }
         else {
             // 上書き禁止属性を除外(2022-08-24~)
             const { $unset, id, project, typeOf, ...updateFields } = params.attributes;
-            doc = await this.priceSpecificationModel.findOneAndUpdate({ _id: { $eq: params.id } }, {
+            const updatedDoc = await this.priceSpecificationModel.findOneAndUpdate({ _id: { $eq: params.id } }, {
                 $set: updateFields
             }, { upsert: false, new: true, projection: { _id: 1 } })
                 .lean() // lean(2024-08-06~)
                 .exec();
+            if (updatedDoc === null) {
+                throw new factory.errors.NotFound(this.priceSpecificationModel.modelName);
+            }
+            savedId = updatedDoc._id.toString();
         }
-        if (doc === null) {
-            throw new factory.errors.NotFound(this.priceSpecificationModel.modelName);
-        }
-        return { id: doc._id?.toString() };
+        return { id: savedId };
     }
     /**
      * 削除する

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

@@ -1,7 +1,7 @@
 import type { BulkWriteResult } from 'mongodb';
 import { Connection, FilterQuery, Types } from 'mongoose';
 import * as factory from '../factory';
-import { IDocTypeAsProduct } from './mongoose/schemas/product';
+import { IDocType, IDocTypeAsProduct } from './mongoose/schemas/product';
 type IKeyOfProjection = keyof factory.product.IProduct | 'hasOfferCatalog.id';
 /**
  * プロダクト検索条件
@@ -103,15 +103,15 @@ export declare class ProductRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, import("./mongoose/schemas/product").IDocType, {}, {}> & IDocTypeAsProduct & import("./mongoose/schemas/product").IDocTypeAsProductOffer & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<IDocTypeAsProduct & import("./mongoose/schemas/product").IDocTypeAsProductOffer & {
         _id: Types.ObjectId;
     } & {
         __v: number;
-    }, import("mongoose").QueryOptions<import("./mongoose/schemas/product").IDocType>, (import("mongoose").Document<unknown, {}, import("./mongoose/schemas/product").IDocType, {}, {}> & IDocTypeAsProduct & import("./mongoose/schemas/product").IDocTypeAsProductOffer & {
+    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<IDocTypeAsProduct & import("./mongoose/schemas/product").IDocTypeAsProductOffer & {
         _id: Types.ObjectId;
     } & {
         __v: number;
-    }) | null>;
+    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.product.IProduct>;
         $unset: any;