@chevre/domain 24.0.0-alpha.5 → 24.0.0-alpha.52

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

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

@@ -1,12 +1,15 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
-export type IDocType = factory.priceSpecification.IPriceSpecification<factory.priceSpecificationType> & {
+type ICategoryCodeChargeSpecification = Omit<factory.priceSpecification.IPriceSpecification<factory.priceSpecificationType.CategoryCodeChargeSpecification>, 'id'>;
+type IMovieTicketTypeChargeSpecification = Omit<factory.priceSpecification.IPriceSpecification<factory.priceSpecificationType.MovieTicketTypeChargeSpecification>, 'id'>;
+export type IDocType = (ICategoryCodeChargeSpecification | IMovieTicketTypeChargeSpecification) & {
     validFrom?: Date;
     validThrough?: Date;
 };
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "PriceSpecification";
 declare function createSchema(): ISchema;
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];

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

@@ -1,14 +1,15 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocTypeAsProduct = Omit<factory.product.IProduct, 'id'>;
 interface IDocTypeAsProductOffer {
     offers?: never;
 }
 type IDocType = IDocTypeAsProduct & IDocTypeAsProductOffer;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "Product";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IDocTypeAsProduct, IDocTypeAsProductOffer, IModel, indexes, modelName };
+export { createSchema, IDocType, IDocTypeAsProduct, IDocTypeAsProductOffer, IModel, indexes, modelName };

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

@@ -1,7 +1,8 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 export interface IProductModel {
-    id?: string;
+    id: string;
     project: {
         id: string;
         typeOf: factory.organizationType.Project;
@@ -22,11 +23,11 @@ export interface IProductModel {
         }[];
     }[];
 }
-type IDocType = IProductModel;
-type IModel = Model<IDocType>;
+type IDocType = Omit<IProductModel, 'id'>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "ProductModel";
 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/productOffer.d.ts

@@ -1,12 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
+import { IVirtuals } from '../virtuals';
 type IDocType = Omit<factory.productOffer.IProductOffer, 'acceptedPaymentMethod' | 'validForMemberTier'> & {
     acceptedPaymentMethod?: factory.productOffer.IAcceptedPaymentMethod;
     validForMemberTier?: factory.productOffer.IValidForMemberTier;
 };
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "ProductOffer";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/schemas/project.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.project.IProject, 'id'> & {
     _id: string;
     aggregateReservation?: any;
     makesOffer?: factory.project.IMakesOffer[];
 };
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "Project";
 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/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'>) & {
+type IDocType = (Omit<factory.reservation.eventReservation.IReservation, 'id'>) & {
     _id: string;
     bookingAgent?: any;
     previousReservationStatus?: factory.reservationStatusType;
 };
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, 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, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, 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, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, 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 = factory.schedule.IEventWithSchedule;
-type IModel = Model<IDocType>;
+type IDocType = Omit<factory.schedule.IEventWithSchedule, 'id'>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, 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,10 +1,11 @@
 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, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "Seller";
 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/sellerReturnPolicy.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.sellerReturnPolicy.ISellerReturnPolicy, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "SellerReturnPolicy";
 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/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, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, 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 = factory.permit.IPermit;
-type IModel = Model<IDocType>;
+type IDocType = Omit<factory.permit.IPermit, 'id'>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, 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,10 +183,10 @@ export interface ISetting {
     useMongo4transactionNumberFrom?: Date;
 }
 type IDocType = ISetting;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "Setting";
 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/task.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.task.ITask<factory.taskName>, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "Task";
 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/task.js

@@ -215,6 +215,7 @@ const indexes = [
             }
         }
     ]
+    // eslint-disable-next-line no-warning-comments
     // TODO add unique index(2025-03-28~)
     // [
     //     { identifier: 1 },

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,10 +20,10 @@ export interface ITicket {
     issuedBy: ITicketIssuedBy;
 }
 type IDocType = Omit<ITicket, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "Ticket";
 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/transaction.d.ts

@@ -1,10 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
-type IDocType = factory.transaction.ITransaction<factory.transactionType>;
-type IModel = Model<IDocType>;
+type IPlaceOrder = Omit<factory.transaction.placeOrder.ITransaction, 'id'>;
+type IReturnOrder = Omit<factory.transaction.returnOrder.ITransaction, 'id'>;
+type IDocType = IPlaceOrder | IReturnOrder;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "Transaction";
 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/transaction.js

@@ -163,6 +163,37 @@ const indexes = [
             }
         }
     ],
+    [
+        // 注文取引のobject.orderNumberも発行されている場合ユニークなはず(2026-02-21~)
+        {
+            typeOf: 1,
+            'object.orderNumber': 1
+        },
+        {
+            name: 'uniquePlacingOrderNumber20260221',
+            unique: true,
+            partialFilterExpression: {
+                typeOf: factory.transactionType.PlaceOrder,
+                'object.orderNumber': { $exists: true },
+                startDate: { $gte: new Date('2026-02-21T11:00:00Z') }
+            }
+        }
+    ],
+    [
+        // 注文取引のobject.orderNumberも発行されている場合ユニークなはず(2026-02-21~)
+        {
+            typeOf: 1,
+            'object.orderNumber': 1
+        },
+        {
+            name: 'uniquePlacingOrderNumber',
+            unique: true,
+            partialFilterExpression: {
+                typeOf: factory.transactionType.PlaceOrder,
+                'object.orderNumber': { $exists: true }
+            }
+        }
+    ],
     [
         // ひとつの注文取引に対する確定返品取引はユニークなはず
         { 'object.order.orderNumber': 1 },

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, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, 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, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, 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,10 +1,11 @@
 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, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
 declare const modelName = "WebSite";
 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/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/movieTicketType.d.ts

@@ -4,7 +4,7 @@ import * as factory from '../factory';
 type IUnset = {
     [key in keyof Pick<IDocType, 'color' | 'image'>]?: 1;
 };
-type IKeyOfProjection = keyof IDocType;
+type IKeyOfProjection = keyof IDocType | 'id';
 /**
  * 決済カード区分リポジトリ
  */
@@ -12,9 +12,7 @@ export declare class MovieTicketTypeRepo {
     private readonly categoryCodeModel;
     constructor(connection: Connection);
     static CREATE_MONGO_CONDITIONS(params: factory.movieTicketType.ISearchConditions): FilterQuery<IDocType>[];
-    static CREATE_AGGREGATE_PROJECTION(inclusion: IKeyOfProjection[]): {
-        [field: string]: AnyExpression;
-    };
+    static CREATE_AGGREGATE_PROJECTION(inclusion: IKeyOfProjection[]): Record<string, AnyExpression>;
     /**
      * 決済カード区分検索
      */
@@ -35,6 +33,7 @@ export declare class MovieTicketTypeRepo {
         id?: string;
         attributes: IDocType & {
             $unset?: IUnset;
+            id?: string;
         };
     }): Promise<{
         id: string;

package/lib/chevre/repo/movieTicketType.js

@@ -203,7 +203,7 @@ class MovieTicketTypeRepo {
         let savedId;
         // let doc: HydratedDocument<{ _id: Types.ObjectId }> | null;
         if (typeof params.id !== 'string') {
-            const { id, $unset, ...creatingDoc } = params.attributes;
+            const { id, $unset, ...creatingDoc } = params.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
             const createResult = await this.categoryCodeModel.create(creatingDoc);
             // doc = createResult;
             if (typeof createResult.id !== 'string') {
@@ -213,7 +213,7 @@ class MovieTicketTypeRepo {
         }
         else {
             // 上書き禁止属性を除外(2022-08-24~)
-            const { id, codeValue, inCodeSet, project, typeOf, $unset, ...updateFields } = params.attributes;
+            const { id, codeValue, inCodeSet, project, typeOf, $unset, ...updateFields } = params.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
             const doc = await this.categoryCodeModel.findOneAndUpdate({ _id: { $eq: params.id } }, {
                 $set: updateFields,
                 ...($unset !== undefined) ? { $unset } : undefined

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

@@ -29,11 +29,11 @@ export declare class NoteRepo {
          */
         update: boolean;
     }): Promise<{
-        bulkWriteResult: BulkWriteResult;
-        modifiedNotes: {
+        bulkWriteResult?: BulkWriteResult;
+        modifiedNotes?: {
             id: string;
         }[];
-    } | void>;
+    }>;
     /**
      * 主題リソースから全メモを削除する
      */

package/lib/chevre/repo/note.js

@@ -234,6 +234,7 @@ class NoteRepo {
                 .exec();
             return { bulkWriteResult, modifiedNotes };
         }
+        return {};
     }
     // /**
     //  * 既知のメモIDリストからメモを削除する

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

@@ -21,7 +21,7 @@ export declare class NoteAboutOrderRepo {
      */
     upsertOrderNoteByIdentifier(params: Pick<INoteAboutOrder, 'about' | 'creator' | 'identifier' | 'project' | 'provider' | 'text' | 'version'>[], options: {
         overwrite: boolean;
-    }): Promise<BulkWriteResult | void>;
+    }): Promise<BulkWriteResult | undefined>;
     updateById(params: {
         id: string;
         attributes: Pick<INoteAboutOrder, 'text' | 'editor'>;

package/lib/chevre/repo/noteAboutOrder.js

@@ -173,6 +173,7 @@ class NoteAboutOrderRepo {
         if (bulkWriteOps.length > 0) {
             return this.noteModel.bulkWrite(bulkWriteOps, { ordered: false });
         }
+        return;
     }
     async updateById(params) {
         const updateFields = {

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

@@ -1,8 +1,6 @@
 import * as factory from '../../factory';
 type KeyOfOffer = keyof Omit<factory.unitPriceOffer.IUnitPriceOffer, 'id'>;
-type IProjection = {
-    [key in KeyOfOffer]?: 0 | 1;
-};
+type IProjection = Partial<Record<KeyOfOffer, 0 | 1>>;
 type IOfferInCatalog = factory.unitPriceOffer.IUnitPriceOffer & {
     /**
      * 集計オファー内インデックス

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

@@ -10,9 +10,7 @@ export declare class OfferRepo implements OfferInCatalogReadOnlyRepo {
     private readonly offerCatalogModel;
     private readonly offerCatalogItemModel;
     constructor(connection: Connection);
-    static CREATE_AGGREGATE_OFFERS_PROJECTION(params: IProjection): {
-        [field: string]: AnyExpression;
-    };
+    static CREATE_AGGREGATE_OFFERS_PROJECTION(params: IProjection): Record<string, AnyExpression>;
     /**
      * カタログIDで単価オファーを全て検索する
      * 必ずカタログデータから単価オファーIDを参照する

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

@@ -1,5 +1,5 @@
 import type { BulkWriteResult } from 'mongodb';
-import type { Connection, Document, FilterQuery } from 'mongoose';
+import type { Connection, FilterQuery } from 'mongoose';
 import * as factory from '../factory';
 import { IDocType } from './mongoose/schemas/offerCatalog';
 export type IAggregatedOfferCatalog = Pick<factory.offerCatalog.IOfferCatalog, 'id' | 'name' | 'description' | 'project' | 'typeOf' | 'identifier' | 'itemOffered' | 'additionalProperty'> & {
@@ -49,11 +49,11 @@ export declare class OfferCatalogRepo {
          */
         itemListElementType: factory.offerCatalog.IItemListElement['typeOf'];
     }): Promise<{
-        bulkWriteResult: BulkWriteResult;
-        modifiedCatalogs: {
+        bulkWriteResult?: BulkWriteResult;
+        modifiedCatalogs?: {
             id: string;
         }[];
-    } | void>;
+    }>;
     /**
      * 同期日時を更新する
      */
@@ -169,19 +169,23 @@ export declare class OfferCatalogRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<Document<unknown, {}, IDocType> & factory.offerCatalog.IOfferCatalog & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
         _id: string;
         alternateName?: any;
         dateSynced?: Date;
     } & Required<{
         _id: string;
-    }>, import("mongoose").QueryOptions<Document<unknown, {}, IDocType> & factory.offerCatalog.IOfferCatalog & {
+    }> & {
+        __v: number;
+    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
         _id: string;
         alternateName?: any;
         dateSynced?: Date;
     } & Required<{
         _id: string;
-    }>>>;
+    }> & {
+        __v: number;
+    }) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.offerCatalog.IOfferCatalog>;
         $unset: any;