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

package/lib/chevre/repo/mongoose/schemas/emailMessages.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.creativeWork.message.email.ICreativeWork;
-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 = "EmailMessage";
 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/event.d.ts

@@ -1,13 +1,14 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocTypeAsScreeningEvent = factory.event.screeningEvent.IAttributes & {
     _id: string;
     aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
 };
 export type IDocType = IDocTypeAsScreeningEvent;
-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 = "Event";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,9 +1,10 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.eventOffer.IEventOffer;
-type IModel = Model<IDocType>;
+import { IVirtuals } from '../virtuals';
+type IDocType = Omit<factory.eventOffer.IEventOffer, '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 = "EventOffer";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,12 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocTypeAsEventSeries = factory.eventSeries.IAttributes & {
     _id: string;
 };
 type IDocType = IDocTypeAsEventSeries;
-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 = "EventSeries";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/schemas/identity.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.softwareApplication.ICertification, 'id'> | Omit<factory.creativeWork.certification.webApplication.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 = "Identity";
 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/identityProvider.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.identityProvider.IIdentityProvider, '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 = "IdentityProvider";
 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/issuer.d.ts

@@ -1,13 +1,14 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-export type IDocType = factory.issuer.IIssuer & {
+import { IVirtuals } from '../virtuals';
+export type IDocType = Omit<factory.issuer.IIssuer, 'id'> & {
     hasMemberProgram?: (factory.issuer.IMemberProgram & {
         hasTiers?: Pick<factory.issuer.IMemberProgramTier, 'identifier' | 'typeOf'>[];
     })[];
 };
-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 = "Issuer";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/schemas/member/global.d.ts

@@ -1,14 +1,15 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../../virtuals';
 import * as factory from '../../../../factory';
 type IMemberOfRole = Pick<factory.iam.IMemberOfRole, 'hasRole' | 'id' | 'image' | 'name' | 'typeOf' | 'username'>;
 type IGlobalMember = Pick<factory.iam.IMember, 'typeOf'> & {
     member: IMemberOfRole;
 };
 type IDocType = IGlobalMember;
-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 = "Member.Global";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IGlobalMember, IModel, indexes, modelName };
+export { createSchema, IDocType, IGlobalMember, IModel, indexes, modelName };

package/lib/chevre/repo/mongoose/schemas/member.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.iam.IMember;
-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 = "Member";
 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/merchantReturnPolicy.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.unitPriceOffer.IOfferMerchantReturnPolicy;
-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 = "MerchantReturnPolicy";
 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/message.d.ts

@@ -1,4 +1,5 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 export type IEmailMessage = factory.creativeWork.message.email.ICreativeWork & {
     datePublished: Date;
@@ -15,11 +16,11 @@ export type IEmailMessage = factory.creativeWork.message.email.ICreativeWork & {
         typeOf: factory.organizationType.Corporation;
     };
 };
-type IDocType = IEmailMessage;
-type IModel = Model<IDocType>;
+type IDocType = Omit<IEmailMessage, '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 = "Message";
 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/movieTicketTypes.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 = factory.movieTicketType.IMovieTicketType;
-type IModel = Model<IDocType>;
+type IDocType = Omit<factory.movieTicketType.IMovieTicketType, '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 = "MovieTicketType";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,12 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Pick<factory.creativeWork.noteDigitalDocument.INoteDigitalDocument, 'creator' | 'dateCreated' | 'dateModified' | 'editor' | 'hasDigitalDocumentPermission' | 'identifier' | 'project' | 'text' | 'typeOf' | 'version'> & {
     about: factory.creativeWork.noteDigitalDocument.IAbout;
     provider: factory.creativeWork.noteDigitalDocument.IProviderAsProject | factory.creativeWork.noteDigitalDocument.IProviderAsSeller;
 };
-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 = "Note";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,13 +1,14 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
-export type IDocType = factory.offerCatalog.IOfferCatalog & {
+export type IDocType = Omit<factory.offerCatalog.IOfferCatalog, 'id'> & {
     _id: string;
     alternateName?: any;
     dateSynced?: 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 = "OfferCatalog";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,13 +1,14 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
-export type IDocType = factory.offerCatalog.IOfferCatalog & {
+export type IDocType = Omit<factory.offerCatalog.IOfferCatalog, 'id'> & {
     _id: string;
     alternateName?: any;
     dateSynced?: 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 = "OfferCatalogItem";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/schemas/offerItemCondition.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.offerItemCondition.IOfferItemCondition;
-type IModel = Model<IDocType>;
+type IDocType = Omit<factory.offerItemCondition.IOfferItemCondition, '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 = "OfferItemCondition";
 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/order.d.ts

@@ -1,12 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.order.IOrder, 'id'> & {
     acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
 };
-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 = "Order";
 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/ownershipInfo.d.ts

@@ -1,12 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
-type IDocType = factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood> & {
+type IDocType = Omit<factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood>, 'id'> & {
     _id: string;
 };
-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 = "OwnershipInfo";
-declare function createSchema(): ISchema;
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
-export { createSchema, IModel, indexes, modelName };
+declare function createSchema(): ISchema;
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -8,20 +8,14 @@ const settings_1 = require("../../../settings");
 const modelName = 'OwnershipInfo';
 exports.modelName = modelName;
 const schemaDefinition = {
-    project: mongoose_1.SchemaTypes.Mixed,
+    project: { type: mongoose_1.SchemaTypes.Mixed, required: true },
     _id: String,
-    typeOf: {
-        type: String,
-        required: true
-    },
-    identifier: {
-        type: String,
-        required: true
-    },
+    typeOf: { type: String, required: true },
+    identifier: { type: String, required: true },
     ownedBy: mongoose_1.SchemaTypes.Mixed,
     acquiredFrom: mongoose_1.SchemaTypes.Mixed,
-    ownedFrom: Date,
-    ownedThrough: Date,
+    ownedFrom: { type: Date, required: true },
+    ownedThrough: { type: Date, required: true },
     typeOfGood: mongoose_1.SchemaTypes.Mixed
 };
 const schemaOptions = {
@@ -48,16 +42,6 @@ const schemaOptions = {
         versionKey: false
     }
 };
-/**
- * 所有権スキーマ
- */
-let schema;
-function createSchema() {
-    if (schema === undefined) {
-        schema = new mongoose_1.Schema(schemaDefinition, schemaOptions);
-    }
-    return schema;
-}
 const indexes = [
     [
         // 識別子はユニークな前提
@@ -81,14 +65,18 @@ const indexes = [
         { typeOf: 1, ownedFrom: -1 },
         { name: 'searchByTypeOf-v2' }
     ],
+    // [
+    //     { identifier: 1, ownedFrom: -1 },
+    //     {
+    //         name: 'searchByIdentifier-v2',
+    //         partialFilterExpression: {
+    //             identifier: { $exists: true }
+    //         }
+    //     }
+    // ],
     [
         { identifier: 1, ownedFrom: -1 },
-        {
-            name: 'searchByIdentifier-v2',
-            partialFilterExpression: {
-                identifier: { $exists: true }
-            }
-        }
+        { name: 'identifier' }
     ],
     [
         { 'acquiredFrom.id': 1, ownedFrom: -1 },
@@ -117,23 +105,27 @@ const indexes = [
             }
         }
     ],
-    [
-        { 'ownedBy.memberOf.membershipNumber': 1, ownedFrom: -1 },
-        {
-            name: 'searchByOwnedByMemberOfMembershipNumber',
-            partialFilterExpression: {
-                'ownedBy.memberOf.membershipNumber': { $exists: true }
-            }
-        }
-    ],
-    [
-        { ownedThrough: -1, ownedFrom: -1 },
-        {
-            name: 'searchByOwnedThrough-v2',
-            partialFilterExpression: {
-                ownedThrough: { $exists: true }
-            }
-        }
+    // [
+    //     { 'ownedBy.memberOf.membershipNumber': 1, ownedFrom: -1 },
+    //     {
+    //         name: 'searchByOwnedByMemberOfMembershipNumber',
+    //         partialFilterExpression: {
+    //             'ownedBy.memberOf.membershipNumber': { $exists: true }
+    //         }
+    //     }
+    // ],
+    // [
+    //     { ownedThrough: -1, ownedFrom: -1 },
+    //     {
+    //         name: 'searchByOwnedThrough-v2',
+    //         partialFilterExpression: {
+    //             ownedThrough: { $exists: true }
+    //         }
+    //     }
+    // ],
+    [
+        { ownedThrough: 1, ownedFrom: -1 },
+        { name: 'ownedThrough' }
     ],
     [
         { 'typeOfGood.typeOf': 1, ownedFrom: -1 },
@@ -144,15 +136,15 @@ const indexes = [
             }
         }
     ],
-    [
-        { 'typeOfGood.reservedTicket.ticketToken': 1, ownedFrom: -1 },
-        {
-            name: 'searchByTypeOfGoofReservedTicketToken',
-            partialFilterExpression: {
-                'typeOfGood.reservedTicket.ticketToken': { $exists: true }
-            }
-        }
-    ],
+    // [
+    //     { 'typeOfGood.reservedTicket.ticketToken': 1, ownedFrom: -1 },
+    //     {
+    //         name: 'searchByTypeOfGoofReservedTicketToken',
+    //         partialFilterExpression: {
+    //             'typeOfGood.reservedTicket.ticketToken': { $exists: true }
+    //         }
+    //     }
+    // ],
     [
         { 'typeOfGood.id': 1, ownedFrom: -1 },
         {
@@ -171,15 +163,15 @@ const indexes = [
             }
         }
     ],
-    [
-        { 'typeOfGood.membershipFor.id': 1, ownedFrom: -1 },
-        {
-            name: 'searchByTypeOfGoodMembershipForId',
-            partialFilterExpression: {
-                'typeOfGood.membershipFor.id': { $exists: true }
-            }
-        }
-    ],
+    // [
+    //     { 'typeOfGood.membershipFor.id': 1, ownedFrom: -1 },
+    //     {
+    //         name: 'searchByTypeOfGoodMembershipForId',
+    //         partialFilterExpression: {
+    //             'typeOfGood.membershipFor.id': { $exists: true }
+    //         }
+    //     }
+    // ],
     [
         { 'typeOfGood.issuedThrough.id': 1, ownedFrom: -1 },
         {
@@ -198,15 +190,15 @@ const indexes = [
             }
         }
     ],
-    [
-        { 'typeOfGood.accountNumber': 1, ownedFrom: -1 },
-        {
-            name: 'searchByTypeOfGoodAccountNumber',
-            partialFilterExpression: {
-                'typeOfGood.accountNumber': { $exists: true }
-            }
-        }
-    ],
+    // [
+    //     { 'typeOfGood.accountNumber': 1, ownedFrom: -1 },
+    //     {
+    //         name: 'searchByTypeOfGoodAccountNumber',
+    //         partialFilterExpression: {
+    //             'typeOfGood.accountNumber': { $exists: true }
+    //         }
+    //     }
+    // ],
     [
         { 'typeOfGood.reservationNumber': 1, ownedFrom: -1 },
         {
@@ -218,3 +210,18 @@ const indexes = [
     ]
 ];
 exports.indexes = indexes;
+/**
+ * 所有権スキーマ
+ */
+let schema;
+function createSchema() {
+    if (schema === undefined) {
+        schema = new mongoose_1.Schema(schemaDefinition, schemaOptions);
+        if (settings_1.MONGO_AUTO_INDEX) {
+            indexes.forEach((indexParams) => {
+                schema?.index(...indexParams);
+            });
+        }
+    }
+    return schema;
+}

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

@@ -1,12 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.service.paymentService.IService, 'id'> & {
     provider?: factory.service.paymentService.IProvider[];
 };
-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 = "PaymentService";
 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/paymentServiceChannel.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.serviceChannel.IServiceChannel, '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 = "PaymentServiceChannel";
 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/pendingReservation.d.ts

@@ -1,5 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
+import { IVirtuals } from '../virtuals';
 interface ISubReservation {
     identifier: string;
 }
@@ -30,10 +31,10 @@ interface IReservationPackage {
     expires: Date;
 }
 type IDocType = IReservationPackage;
-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 = "PendingReservation";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, ISubReservation, IReservationPackage, indexes, modelName };
+export { createSchema, IDocType, IModel, ISubReservation, IReservationPackage, indexes, modelName };

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

@@ -1,5 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
+import { IVirtuals } from '../virtuals';
 interface IAggregateReservation {
     project: {
         id: string;
@@ -15,10 +16,10 @@ interface IAggregateReservation {
     expires: Date;
 }
 type IDocType = IAggregateReservation;
-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 = "PendingReservationAggregate";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, IAggregateReservation, indexes, modelName };
+export { createSchema, IDocType, IModel, IAggregateReservation, indexes, modelName };

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

@@ -1,4 +1,5 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type ISeatSection = Pick<factory.place.screeningRoomSection.IPlace, 'additionalProperty' | 'branchCode' | 'name' | 'typeOf'> & {
     containsPlace?: factory.place.seat.IPlace[];
@@ -9,9 +10,9 @@ type IDocType = Omit<factory.place.screeningRoom.IPlace, 'containsPlace'> & {
     smokingAllowed?: boolean;
     containsPlace: ISeatSection[];
 };
-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 = "Place";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;