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

package/lib/chevre/repo/mongoose/schemas/aggregateOrder.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 IAggregateOrder {
     orderCount: number;
@@ -14,9 +15,9 @@ export interface IDocType {
     };
     typeOf: factory.personType.Person | factory.placeType.Seat;
 }
-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 = "AggregateOrder";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/schemas/aggregateReservation.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 IAggregateReservation {
     project: {
@@ -14,10 +15,10 @@ export interface IAggregateReservation {
     aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
 }
 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 = "AggregateReservation";
 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/aggregation.d.ts

@@ -1,9 +1,10 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 type IDocType = any;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, 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 = "Aggregation";
 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/assetTransaction.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.assetTransaction.ITransaction<factory.assetTransactionType.CancelReservation> | factory.assetTransaction.ITransaction<factory.assetTransactionType.MoneyTransfer> | factory.assetTransaction.ITransaction<factory.assetTransactionType.Pay> | factory.assetTransaction.ITransaction<factory.assetTransactionType.Refund> | factory.assetTransaction.ITransaction<factory.assetTransactionType.RegisterService> | factory.assetTransaction.ITransaction<factory.assetTransactionType.Reserve>) & {
     seller?: any;
 };
-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 = "AssetTransaction";
 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/authorization.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.authorization.IAuthorization, '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 = "Authorization";
 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/categoryCode.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.categoryCode.ICategoryCode;
-type IModel = Model<IDocType>;
+type IDocType = Omit<factory.categoryCode.ICategoryCode, '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 = "CategoryCode";
 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/civicStructure.d.ts

@@ -1,11 +1,12 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 export type IDocType = Omit<factory.place.movieTheater.IPlace, 'id'> & {
     hasPOS?: factory.place.movieTheater.IPOS[];
 };
-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 = "CivicStructure";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/schemas/comments.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.comment.IComment;
-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 = "Comment";
 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/creativeWork.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.creativeWork.movie.ICreativeWork & {
+type IDocType = Omit<factory.creativeWork.movie.ICreativeWork, 'id'> & {
     description?: 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 = "CreativeWork";
 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/customer.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.customer.ICustomer;
-type IModel = Model<IDocType>;
+type IDocType = Omit<factory.customer.ICustomer, '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 = "Customer";
 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/customerType.d.ts

@@ -1,11 +1,12 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 export type ICustomerType = Pick<factory.categoryCode.ICategoryCode, 'codeValue' | 'id' | 'name' | 'typeOf'>;
-type IDocType = ICustomerType;
-type IModel = Model<IDocType>;
+type IDocType = Omit<ICustomerType, '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 = "CustomerType";
 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/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 };