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

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;

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

@@ -3,9 +3,9 @@ import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 export type ICustomerType = Pick<factory.categoryCode.ICategoryCode, 'codeValue' | 'id' | 'name' | 'typeOf'>;
 type IDocType = Omit<ICustomerType, '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 = "CustomerType";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/schemas/emailMessages.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.message.email.ICreativeWork;
-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 = "EmailMessage";
 declare function createSchema(): ISchema;
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];

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

@@ -6,9 +6,9 @@ type IDocTypeAsScreeningEvent = factory.event.screeningEvent.IAttributes & {
     aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
 };
 export type IDocType = IDocTypeAsScreeningEvent;
-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 = "Event";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/schemas/eventOffer.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.eventOffer.IEventOffer, '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 = "EventOffer";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -5,9 +5,9 @@ type IDocTypeAsEventSeries = factory.eventSeries.IAttributes & {
     _id: string;
 };
 type IDocType = IDocTypeAsEventSeries;
-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 = "EventSeries";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/schemas/identity.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.creativeWork.certification.softwareApplication.ICertification, 'id'> | Omit<factory.creativeWork.certification.webApplication.ICertification, '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 = "Identity";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

package/lib/chevre/repo/mongoose/schemas/identityProvider.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.identityProvider.IIdentityProvider, '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 = "IdentityProvider";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -6,9 +6,9 @@ export type IDocType = Omit<factory.issuer.IIssuer, 'id'> & {
         hasTiers?: Pick<factory.issuer.IMemberProgramTier, 'identifier' | 'typeOf'>[];
     })[];
 };
-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 = "Issuer";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -6,9 +6,9 @@ type IGlobalMember = Pick<factory.iam.IMember, 'typeOf'> & {
     member: IMemberOfRole;
 };
 type IDocType = IGlobalMember;
-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 = "Member.Global";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;