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

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

@@ -1,5 +1,6 @@
 import { Connection, FilterQuery, QueryOptions } from 'mongoose';
 import * as factory from '../factory';
+import { IDocType } from './mongoose/schemas/identity';
 type ISavingSoftwareApplicationIdentity = Pick<factory.creativeWork.certification.softwareApplication.ICertification, 'about' | 'project' | 'typeOf'>;
 type ISavingWebApplicationIdentity = Pick<factory.creativeWork.certification.webApplication.ICertification, 'about' | 'project' | 'typeOf'>;
 export type ISavingIdentity = (ISavingSoftwareApplicationIdentity | ISavingWebApplicationIdentity) & {
@@ -9,9 +10,7 @@ export type ISavingIdentity = (ISavingSoftwareApplicationIdentity | ISavingWebAp
     issuedBy: factory.creativeWork.certification.webApplication.IIssuedBy[];
 };
 interface IUnset {
-    $unset?: {
-        [key: string]: 1;
-    };
+    $unset?: Record<string, 1>;
 }
 type IIdentityWithId = (factory.creativeWork.certification.softwareApplication.ICertification | factory.creativeWork.certification.webApplication.ICertification) & {
     id: string;
@@ -37,15 +36,23 @@ export declare class IdentityRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, Omit<import("@chevre/factory/lib/creativeWork/certification/softwareApplication").ICertification, "id"> | Omit<import("@chevre/factory/lib/creativeWork/certification/webApplication").ICertification, "id">> & ((Omit<import("@chevre/factory/lib/creativeWork/certification/softwareApplication").ICertification, "id"> & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & ((Omit<import("@chevre/factory/lib/creativeWork/certification/softwareApplication").ICertification, "id"> & {
         _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
     }) | (Omit<import("@chevre/factory/lib/creativeWork/certification/webApplication").ICertification, "id"> & {
         _id: import("mongoose").Types.ObjectId;
-    })), QueryOptions<import("mongoose").Document<unknown, {}, Omit<import("@chevre/factory/lib/creativeWork/certification/softwareApplication").ICertification, "id"> | Omit<import("@chevre/factory/lib/creativeWork/certification/webApplication").ICertification, "id">> & ((Omit<import("@chevre/factory/lib/creativeWork/certification/softwareApplication").ICertification, "id"> & {
+    } & {
+        __v: number;
+    })), QueryOptions<IDocType>, (import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & ((Omit<import("@chevre/factory/lib/creativeWork/certification/softwareApplication").ICertification, "id"> & {
         _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
     }) | (Omit<import("@chevre/factory/lib/creativeWork/certification/webApplication").ICertification, "id"> & {
         _id: import("mongoose").Types.ObjectId;
-    }))>>;
+    } & {
+        __v: number;
+    }))) | null>;
     updateIssuedBy2array(params: Pick<ISavingIdentity, 'issuedBy'> & {
         id: string;
     }): Promise<void>;

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

@@ -1,12 +1,11 @@
 import { Connection, FilterQuery, QueryOptions } from 'mongoose';
 import * as factory from '../factory';
+import { IDocType } from './mongoose/schemas/identityProvider';
 export type ISavingIdentityProvider = Pick<factory.identityProvider.IIdentityProvider, 'identifier' | 'project' | 'typeOf'> & {
     id?: never;
 };
 interface IUnset {
-    $unset?: {
-        [key: string]: 1;
-    };
+    $unset?: Record<string, 1>;
 }
 type IIdentityProviderWithId = factory.identityProvider.IIdentityProvider & {
     id: string;
@@ -32,27 +31,15 @@ export declare class IdentityProviderRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, {
-        project: Pick<factory.project.IProject, "id" | "typeOf">;
-        identifier: string;
-        typeOf: factory.organizationType.Organization;
-    }> & {
-        project: Pick<factory.project.IProject, "id" | "typeOf">;
-        identifier: string;
-        typeOf: factory.organizationType.Organization;
-    } & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & IDocType & {
         _id: import("mongoose").Types.ObjectId;
-    }, QueryOptions<import("mongoose").Document<unknown, {}, {
-        project: Pick<factory.project.IProject, "id" | "typeOf">;
-        identifier: string;
-        typeOf: factory.organizationType.Organization;
-    }> & {
-        project: Pick<factory.project.IProject, "id" | "typeOf">;
-        identifier: string;
-        typeOf: factory.organizationType.Organization;
     } & {
+        __v: number;
+    }, QueryOptions<IDocType>, (import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & IDocType & {
         _id: import("mongoose").Types.ObjectId;
-    }>>;
+    } & {
+        __v: number;
+    }) | null>;
     unsetUnnecessaryFields(params: {
         filter: any;
         $unset: any;

package/lib/chevre/repo/identityProvider.js

@@ -67,7 +67,7 @@ class IdentityProviderRepo {
             if (savingId === '') {
                 throw new factory.errors.ArgumentNull('id');
             }
-            const { id, identifier, project, typeOf, $unset, ...updateFields } = params.attributes;
+            const { id, identifier, project, typeOf, $unset, ...updateFields } = params.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
             const filter = {
                 _id: { $eq: savingId },
                 'project.id': { $eq: project.id }
@@ -90,7 +90,7 @@ class IdentityProviderRepo {
             savedId = savingId;
         }
         else {
-            const { $unset, id, ...createParams } = params.attributes;
+            const { $unset, id, ...createParams } = params.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
             const result = await this.identityProviderModel.insertMany(createParams, { rawResult: true });
             const insertedId = result.insertedIds?.[0]?.toHexString();
             if (typeof insertedId !== 'string') {

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

@@ -35,22 +35,22 @@ export declare class IssuerRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType> & factory.issuer.IIssuer & {
-        hasMemberProgram?: (
-        /**
-         * 発行者リポジトリ
-         */
-        factory.issuer.IMemberProgram & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<factory.issuer.IIssuer, "id"> & {
+        hasMemberProgram?: (factory.issuer.IMemberProgram & {
             hasTiers?: Pick<factory.issuer.IMemberProgramTier, "identifier" | "typeOf">[];
         })[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }, import("mongoose").QueryOptions<import("mongoose").Document<unknown, {}, IDocType> & factory.issuer.IIssuer & {
+    } & {
+        __v: number;
+    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<factory.issuer.IIssuer, "id"> & {
         hasMemberProgram?: (factory.issuer.IMemberProgram & {
             hasTiers?: Pick<factory.issuer.IMemberProgramTier, "identifier" | "typeOf">[];
         })[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }>>;
+    } & {
+        __v: number;
+    }) | null>;
 }
 export {};

package/lib/chevre/repo/issuer.js

@@ -59,12 +59,12 @@ class IssuerRepo {
         let savedId;
         let doc;
         if (params.id === '') {
-            const { id, ...creatingParams } = params;
+            const { id, ...creatingParams } = params; // eslint-disable-line @typescript-eslint/no-unused-vars
             doc = await this.issuerModel.create(creatingParams);
             savedId = doc.id;
         }
         else {
-            const { id, identifier, project, ...updateFields } = params;
+            const { id, identifier, project, ...updateFields } = params; // eslint-disable-line @typescript-eslint/no-unused-vars
             doc = await this.issuerModel.findOneAndUpdate({ _id: { $eq: params.id } }, { $set: updateFields }, { upsert: false, new: true, projection: { _id: 1 } })
                 .exec();
             savedId = params.id;
@@ -75,7 +75,7 @@ class IssuerRepo {
         return { id: savedId };
     }
     async renameIssuerIdentifier(params) {
-        const { id, ...updateFields } = params;
+        const { id, ...updateFields } = params; // eslint-disable-line @typescript-eslint/no-unused-vars
         const doc = await this.issuerModel.findOneAndUpdate({ _id: { $eq: params.id } }, { $set: updateFields }, { upsert: false, new: true, projection: { _id: 1 } })
             .exec();
         const savedId = params.id;

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

@@ -174,11 +174,15 @@ export declare class MemberRepo {
             id: string;
         };
     }): Promise<string[]>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, factory.iam.IMember> & factory.iam.IMember & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, factory.iam.IMember, import("./mongoose/virtuals").IVirtuals, {}> & factory.iam.IMember & {
         _id: import("mongoose").Types.ObjectId;
-    }, import("mongoose").QueryOptions<import("mongoose").Document<unknown, {}, factory.iam.IMember> & factory.iam.IMember & {
+    } & {
+        __v: number;
+    }, import("mongoose").QueryOptions<factory.iam.IMember>, (import("mongoose").Document<unknown, Record<string, never>, factory.iam.IMember, import("./mongoose/virtuals").IVirtuals, {}> & factory.iam.IMember & {
         _id: import("mongoose").Types.ObjectId;
-    }>>;
+    } & {
+        __v: number;
+    }) | null>;
     unsetUnnecessaryFields(params: {
         filter: any;
         $unset: any;

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

@@ -20,7 +20,7 @@ export declare class MerchantReturnPolicyRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<Document<unknown, {}, factory.unitPriceOffer.IOfferMerchantReturnPolicy> & Pick<factory.merchantReturnPolicy.IMerchantReturnPolicy, "typeOf" | "customerRemorseReturnFees" | "customerRemorseReturnFeesMovieTicket"> & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<Document<unknown, Record<string, never>, factory.unitPriceOffer.IOfferMerchantReturnPolicy, import("./mongoose/virtuals").IVirtuals, {}> & Pick<factory.merchantReturnPolicy.IMerchantReturnPolicy, "typeOf" | "customerRemorseReturnFees" | "customerRemorseReturnFeesMovieTicket"> & {
         customerRemorseReturnFees: factory.merchantReturnPolicy.ICustomerRemorseReturnFees;
         customerRemorseReturnFeesMovieTicket: factory.merchantReturnPolicy.ICustomerRemorseReturnFeesMovieTicket;
         project: Pick<factory.project.IProject, "id" | "typeOf">;
@@ -30,7 +30,9 @@ export declare class MerchantReturnPolicyRepo {
         name?: import("@chevre/factory/lib/multilingualString").IMultilingualString;
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }, import("mongoose").QueryOptions<Document<unknown, {}, factory.unitPriceOffer.IOfferMerchantReturnPolicy> & Pick<factory.merchantReturnPolicy.IMerchantReturnPolicy, "typeOf" | "customerRemorseReturnFees" | "customerRemorseReturnFeesMovieTicket"> & {
+    } & {
+        __v: number;
+    }, import("mongoose").QueryOptions<factory.unitPriceOffer.IOfferMerchantReturnPolicy>, (Document<unknown, Record<string, never>, factory.unitPriceOffer.IOfferMerchantReturnPolicy, import("./mongoose/virtuals").IVirtuals, {}> & Pick<factory.merchantReturnPolicy.IMerchantReturnPolicy, "typeOf" | "customerRemorseReturnFees" | "customerRemorseReturnFeesMovieTicket"> & {
         customerRemorseReturnFees: factory.merchantReturnPolicy.ICustomerRemorseReturnFees;
         customerRemorseReturnFeesMovieTicket: factory.merchantReturnPolicy.ICustomerRemorseReturnFeesMovieTicket;
         project: Pick<factory.project.IProject, "id" | "typeOf">;
@@ -40,5 +42,7 @@ export declare class MerchantReturnPolicyRepo {
         name?: import("@chevre/factory/lib/multilingualString").IMultilingualString;
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }>>;
+    } & {
+        __v: number;
+    }) | null>;
 }

package/lib/chevre/repo/merchantReturnPolicy.js

@@ -103,7 +103,7 @@ class MerchantReturnPolicyRepo {
         }
         else {
             // 上書き禁止属性を除外(2022-08-24~)
-            const { id, identifier, project, typeOf, ...updateFields } = params;
+            const { id, identifier, project, typeOf, ...updateFields } = params; // eslint-disable-line @typescript-eslint/no-unused-vars
             doc = await this.merchantReturnPolicyModel.findOneAndUpdate({ _id: params.id }, updateFields, { upsert: false, new: true })
                 .exec();
         }

package/lib/chevre/repo/message.js

@@ -125,7 +125,7 @@ class MessageRepo {
     //                 throw new factory.errors.ArgumentNull('text');
     //             }
     //             // リソースのユニークネスを保証するfilter
-    //             const filter: Filter<IEmailMessage> = {
+    //             const filter: RootFilterQuery<IEmailMessage> = {
     //                 // typeOf: { $eq: factory.creativeWorkType.EmailMessage },
     //                 'project.id': { $eq: project.id },
     //                 identifier: { $eq: identifier }

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

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

package/lib/chevre/repo/mongoose/schemas/account.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.account.IAccount;
-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 = "Account";
 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/accountTitle.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.accountTitle.IAccountTitle;
-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 = "AccountTitle";
 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/accountTransaction.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.account.transaction.ITransaction<factory.account.transactionType>;
-type IModel = Model<IDocType>;
+type IDocType = Omit<factory.account.transaction.ITransaction<factory.account.transactionType>, '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>;
 declare const modelName = "AccountTransaction";
 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/accountingReport.d.ts

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

package/lib/chevre/repo/mongoose/schemas/action.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.action.IAction<factory.action.IAttributes<factory.actionType, any, any>>, 'id'> & {
     identifier?: 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 = "Action";
 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/actionRecipe.d.ts

@@ -1,4 +1,5 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = factory.recipe.IRecipe & {
     recipeFor: {
@@ -7,10 +8,10 @@ type IDocType = factory.recipe.IRecipe & {
     dateCreated?: Date;
     dateModified?: 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 = "ActionRecipe";
 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/additionalProperty.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.additionalProperty.IAdditionalProperty;
-type IModel = Model<IDocType>;
+type IDocType = Omit<factory.additionalProperty.IAdditionalProperty, '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 = "AdditionalProperty";
 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/advanceBookingRequirement.d.ts

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

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

@@ -1,12 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
-export interface IDocType extends factory.aggregateOffer.IAggregateOffer {
+export interface IDocType extends Omit<factory.aggregateOffer.IAggregateOffer, 'id'> {
     _id: string;
     includedInDataCatalog?: 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 = "AggregateOffer";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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 };