@chevre/domain 24.0.0-alpha.4 → 24.0.0-alpha.40

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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Place";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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, {}, {}, 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;
-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.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;