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

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

@@ -288,30 +288,30 @@ export declare class EventRepo {
             validationErrors: import("mongoose").Error[];
         } | undefined;
     }>;
-    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, import("@chevre/factory/lib/event/screeningEvent").IAttributes & {
+    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, import("@chevre/factory/lib/event/screeningEvent").IAttributes & {
         _id: string;
         aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
-    }, import("./mongoose/virtuals").IVirtuals, {}> & Omit<import("@chevre/factory/lib/event/screeningEvent").IAttributes & {
+    }, import("./mongoose/virtuals").IVirtuals, {}> & import("@chevre/factory/lib/event/screeningEvent").IAttributes & {
         _id: string;
         aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
     } & Required<{
         _id: string;
     }> & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<import("@chevre/factory/lib/event/screeningEvent").IAttributes & {
+    }, import("mongoose").QueryOptions<import("@chevre/factory/lib/event/screeningEvent").IAttributes & {
         _id: string;
         aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
-    }>, (import("mongoose").Document<unknown, {}, import("@chevre/factory/lib/event/screeningEvent").IAttributes & {
+    }>, (import("mongoose").Document<unknown, Record<string, never>, import("@chevre/factory/lib/event/screeningEvent").IAttributes & {
         _id: string;
         aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
-    }, import("./mongoose/virtuals").IVirtuals, {}> & Omit<import("@chevre/factory/lib/event/screeningEvent").IAttributes & {
+    }, import("./mongoose/virtuals").IVirtuals, {}> & import("@chevre/factory/lib/event/screeningEvent").IAttributes & {
         _id: string;
         aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
     } & Required<{
         _id: string;
     }> & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
+    }) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.event.screeningEvent.IEvent>;
         $unset: IUnset;

package/lib/chevre/repo/event.js

@@ -149,7 +149,7 @@ class EventRepo {
         }
         let params;
         switch (conditions.typeOf) {
-            case factory.eventType.ScreeningEvent:
+            case factory.eventType.ScreeningEvent: {
                 params = conditions;
                 /* istanbul ignore else */
                 if (typeof params.name === 'string' && params.name.length > 0) {
@@ -247,6 +247,7 @@ class EventRepo {
                     });
                 }
                 break;
+            }
             case factory.eventType.ScreeningEventSeries:
                 throw new factory.errors.Internal('typeOf: ScreeningEventSeries discontinued');
             default:
@@ -326,7 +327,9 @@ class EventRepo {
                     bulkWriteOps.push({ updateOne });
                 }
                 else {
-                    const { id, coaInfo, description, maximumAttendeeCapacity, remainingAttendeeCapacity, checkInCount, attendeeCount, aggregateReservation, ...setOnInsertFields } = $set;
+                    const { id, coaInfo, description, // eslint-disable-line @typescript-eslint/no-unused-vars
+                    maximumAttendeeCapacity, remainingAttendeeCapacity, checkInCount, attendeeCount, aggregateReservation, // eslint-disable-line @typescript-eslint/no-unused-vars
+                    ...setOnInsertFields } = $set;
                     const setOnInsert = {
                         ...setOnInsertFields,
                         identifier,
@@ -394,7 +397,10 @@ class EventRepo {
      */
     async updateEventById(params) {
         let doc;
-        const { identifier, project, typeOf, organizer, aggregateReservation, maximumAttendeeCapacity, remainingAttendeeCapacity, checkInCount, attendeeCount, coaInfo, ...updateFields
+        const { identifier, project, typeOf, // eslint-disable-line @typescript-eslint/no-unused-vars
+        organizer, aggregateReservation, maximumAttendeeCapacity, remainingAttendeeCapacity, checkInCount, attendeeCount, // eslint-disable-line @typescript-eslint/no-unused-vars
+        coaInfo, // eslint-disable-line @typescript-eslint/no-unused-vars
+        ...updateFields
         // maximumPhysicalAttendeeCapacity, additionalProperty,
         // eventStatus, location, name, superEvent, offers,
         // doorTime, endDate, startDate
@@ -449,7 +455,7 @@ class EventRepo {
                 const upsert = p.upsert === true;
                 if (p.attributes.typeOf === factory.eventType.ScreeningEvent) {
                     // 上書き禁止属性を除外(2022-08-24~)
-                    const { identifier, project, typeOf, remainingAttendeeCapacity, ...updateFields } = p.attributes;
+                    const { identifier, project, typeOf, remainingAttendeeCapacity, ...updateFields } = p.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
                     bulkWriteOps.push({
                         updateOne: {
                             filter: {

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

@@ -86,25 +86,25 @@ export declare class EventSeriesRepo {
     }): Promise<{
         maxVersion: string;
     }>;
-    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, factory.eventSeries.IAttributes & {
+    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, factory.eventSeries.IAttributes & {
         _id: string;
-    }, import("./mongoose/virtuals").IVirtuals, {}> & Omit<factory.eventSeries.IAttributes & {
+    }, import("./mongoose/virtuals").IVirtuals, {}> & factory.eventSeries.IAttributes & {
         _id: string;
     } & Required<{
         _id: string;
     }> & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<factory.eventSeries.IAttributes & {
+    }, import("mongoose").QueryOptions<factory.eventSeries.IAttributes & {
         _id: string;
-    }>, (import("mongoose").Document<unknown, {}, factory.eventSeries.IAttributes & {
+    }>, (import("mongoose").Document<unknown, Record<string, never>, factory.eventSeries.IAttributes & {
         _id: string;
-    }, import("./mongoose/virtuals").IVirtuals, {}> & Omit<factory.eventSeries.IAttributes & {
+    }, import("./mongoose/virtuals").IVirtuals, {}> & factory.eventSeries.IAttributes & {
         _id: string;
     } & Required<{
         _id: string;
     }> & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
+    }) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.eventSeries.IEvent>;
         $unset: IUnset;

package/lib/chevre/repo/eventSeries.js

@@ -326,7 +326,7 @@ class EventSeriesRepo {
                     'workPerformed.identifier': { $exists: true, $eq: $set.workPerformed.identifier },
                     'workPerformed.version': { $exists: true, $eq: version }
                 });
-                const { identifier, project, typeOf, ...setFields } = $set;
+                const { identifier, project, typeOf, ...setFields } = $set; // eslint-disable-line @typescript-eslint/no-unused-vars
                 const setOnInsert = {
                     project,
                     typeOf,
@@ -449,7 +449,7 @@ class EventSeriesRepo {
         if (Array.isArray(params)) {
             params.forEach((p) => {
                 // 上書き禁止属性を除外(2022-08-24~)
-                const { identifier, project, typeOf, ...updateFields } = p.attributes;
+                const { identifier, project, typeOf, ...updateFields } = p.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
                 bulkWriteOps.push({
                     updateOne: {
                         filter: {

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

@@ -10,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;
@@ -38,7 +36,7 @@ export declare class IdentityRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<(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;
@@ -46,7 +44,7 @@ export declare class IdentityRepo {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }), "id"> & import("./mongoose/virtuals").IVirtuals, QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<(Omit<import("@chevre/factory/lib/creativeWork/certification/softwareApplication").ICertification, "id"> & {
+    })), 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;
@@ -54,7 +52,7 @@ export declare class IdentityRepo {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }), "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
+    }))) | null>;
     updateIssuedBy2array(params: Pick<ISavingIdentity, 'issuedBy'> & {
         id: string;
     }): Promise<void>;

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

@@ -5,9 +5,7 @@ export type ISavingIdentityProvider = Pick<factory.identityProvider.IIdentityPro
     id?: never;
 };
 interface IUnset {
-    $unset?: {
-        [key: string]: 1;
-    };
+    $unset?: Record<string, 1>;
 }
 type IIdentityProviderWithId = factory.identityProvider.IIdentityProvider & {
     id: string;
@@ -33,15 +31,15 @@ export declare class IdentityProviderRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<IDocType & {
+    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;
     } & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals, QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<IDocType & {
+    }, QueryOptions<IDocType>, (import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & IDocType & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
+    }) | 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,7 +35,7 @@ export declare class IssuerRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.issuer.IIssuer, "id"> & {
+    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">[];
         })[];
@@ -43,7 +43,7 @@ export declare class IssuerRepo {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.issuer.IIssuer, "id"> & {
+    }, 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">[];
         })[];
@@ -51,6 +51,6 @@ export declare class IssuerRepo {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
+    }) | 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,15 +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, import("./mongoose/virtuals").IVirtuals, {}> & Omit<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;
     } & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<factory.iam.IMember>, (import("mongoose").Document<unknown, {}, factory.iam.IMember, import("./mongoose/virtuals").IVirtuals, {}> & Omit<factory.iam.IMember & {
+    }, 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;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
+    }) | 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, import("./mongoose/virtuals").IVirtuals, {}> & Omit<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">;
@@ -32,7 +32,7 @@ export declare class MerchantReturnPolicyRepo {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<factory.unitPriceOffer.IOfferMerchantReturnPolicy>, (Document<unknown, {}, factory.unitPriceOffer.IOfferMerchantReturnPolicy, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Pick<factory.merchantReturnPolicy.IMerchantReturnPolicy, "typeOf" | "customerRemorseReturnFees" | "customerRemorseReturnFeesMovieTicket"> & {
+    }, 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">;
@@ -44,5 +44,5 @@ export declare class MerchantReturnPolicyRepo {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
+    }) | 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/mongoose/schemas/acceptedPaymentMethod.d.ts

@@ -2,9 +2,9 @@ import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from '
 import * as factory from '../../../factory';
 import { IVirtuals } from '../virtuals';
 type IDocType = Omit<factory.acceptedPaymentMethodOffer.IAcceptedPaymentMethodOffer, 'id'>;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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

@@ -2,9 +2,9 @@ import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from '
 import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = factory.account.IAccount;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;

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

@@ -2,9 +2,9 @@ import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from '
 import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = factory.accountTitle.IAccountTitle;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;

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

@@ -2,9 +2,9 @@ import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from '
 import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.account.transaction.ITransaction<factory.account.transactionType>, 'id'>;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition>;
+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;

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

@@ -3,9 +3,9 @@ import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IAccountingReport = factory.report.accountingReport.IReportDocument;
 type IDocType = IAccountingReport;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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

@@ -4,9 +4,9 @@ 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, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;

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

@@ -8,9 +8,9 @@ type IDocType = factory.recipe.IRecipe & {
     dateCreated?: Date;
     dateModified?: Date;
 };
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;

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

@@ -2,9 +2,9 @@ import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from '
 import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.additionalProperty.IAdditionalProperty, 'id'>;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;

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

@@ -2,9 +2,9 @@ import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from '
 import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.advanceBookingRequirement.IAdvanceBookingRequirement, 'id'>;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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

@@ -5,9 +5,9 @@ export interface IDocType extends Omit<factory.aggregateOffer.IAggregateOffer, '
     _id: string;
     includedInDataCatalog?: any[];
 }
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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

@@ -15,9 +15,9 @@ export interface IDocType {
     };
     typeOf: factory.personType.Person | factory.placeType.Seat;
 }
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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

@@ -15,9 +15,9 @@ export interface IAggregateReservation {
     aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
 }
 type IDocType = IAggregateReservation;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;

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

@@ -1,9 +1,9 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import { IVirtuals } from '../virtuals';
 type IDocType = any;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;

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

@@ -4,9 +4,9 @@ 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, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;

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

@@ -2,9 +2,9 @@ import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from '
 import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.authorization.IAuthorization, 'id'>;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;

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

@@ -2,9 +2,9 @@ import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from '
 import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.categoryCode.ICategoryCode, 'id'>;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;

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

@@ -4,9 +4,9 @@ import * as factory from '../../../factory';
 export type IDocType = Omit<factory.place.movieTheater.IPlace, 'id'> & {
     hasPOS?: factory.place.movieTheater.IPOS[];
 };
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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

@@ -2,9 +2,9 @@ import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from '
 import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = factory.creativeWork.comment.IComment;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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][];

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

@@ -4,9 +4,9 @@ import * as factory from '../../../factory';
 type IDocType = Omit<factory.creativeWork.movie.ICreativeWork, 'id'> & {
     description?: string;
 };
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;

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

@@ -2,9 +2,9 @@ import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from '
 import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.customer.ICustomer, 'id'>;
-type IModel = Model<IDocType, {}, {}, IVirtuals>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, 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;