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

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

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

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

@@ -17,9 +17,9 @@ export type IEmailMessage = factory.creativeWork.message.email.ICreativeWork & {
     };
 };
 type IDocType = Omit<IEmailMessage, '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 = "Message";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

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

@@ -5,9 +5,9 @@ type IDocType = Pick<factory.creativeWork.noteDigitalDocument.INoteDigitalDocume
     about: factory.creativeWork.noteDigitalDocument.IAbout;
     provider: factory.creativeWork.noteDigitalDocument.IProviderAsProject | factory.creativeWork.noteDigitalDocument.IProviderAsSeller;
 };
-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 = "Note";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -6,9 +6,9 @@ export type IDocType = Omit<factory.offerCatalog.IOfferCatalog, 'id'> & {
     alternateName?: any;
     dateSynced?: 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 = "OfferCatalog";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -6,9 +6,9 @@ export type IDocType = Omit<factory.offerCatalog.IOfferCatalog, 'id'> & {
     alternateName?: any;
     dateSynced?: 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 = "OfferCatalogItem";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

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

@@ -4,9 +4,9 @@ import * as factory from '../../../factory';
 type IDocType = Omit<factory.order.IOrder, 'id'> & {
     acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
 };
-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 = "Order";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -4,9 +4,9 @@ import * as factory from '../../../factory';
 type IDocType = Omit<factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood>, 'id'> & {
     _id: 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 = "OwnershipInfo";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -4,9 +4,9 @@ import * as factory from '../../../factory';
 type IDocType = Omit<factory.service.paymentService.IService, 'id'> & {
     provider?: factory.service.paymentService.IProvider[];
 };
-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 = "PaymentService";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

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

@@ -31,9 +31,9 @@ interface IReservationPackage {
     expires: Date;
 }
 type IDocType = IReservationPackage;
-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 = "PendingReservation";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -16,9 +16,9 @@ interface IAggregateReservation {
     expires: Date;
 }
 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 = "PendingReservationAggregate";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -10,9 +10,9 @@ type IDocType = Omit<factory.place.screeningRoom.IPlace, 'containsPlace'> & {
     smokingAllowed?: boolean;
     containsPlace: ISeatSection[];
 };
-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 = "Place";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

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

@@ -7,9 +7,9 @@ export type IDocType = (ICategoryCodeChargeSpecification | IMovieTicketTypeCharg
     validFrom?: Date;
     validThrough?: 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 = "PriceSpecification";
 declare function createSchema(): ISchema;
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];

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

@@ -6,9 +6,9 @@ interface IDocTypeAsProductOffer {
     offers?: never;
 }
 type IDocType = IDocTypeAsProduct & IDocTypeAsProductOffer;
-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 = "Product";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -24,9 +24,9 @@ export interface IProductModel {
     }[];
 }
 type IDocType = Omit<IProductModel, '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 = "ProductModel";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -5,9 +5,9 @@ type IDocType = Omit<factory.productOffer.IProductOffer, 'acceptedPaymentMethod'
     acceptedPaymentMethod?: factory.productOffer.IAcceptedPaymentMethod;
     validForMemberTier?: factory.productOffer.IValidForMemberTier;
 };
-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 = "ProductOffer";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -6,9 +6,9 @@ type IDocType = Omit<factory.project.IProject, 'id'> & {
     aggregateReservation?: any;
     makesOffer?: factory.project.IMakesOffer[];
 };
-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 = "Project";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -6,9 +6,9 @@ type IDocType = (Omit<factory.reservation.IReservation<factory.reservationType.E
     bookingAgent?: any;
     previousReservationStatus?: factory.reservationStatusType;
 };
-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 = "Reservation";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -3,9 +3,9 @@ import * as factory from '../../../factory';
 import { IVirtuals } from '../virtuals';
 export type IWebAPI = Omit<factory.service.webAPI.IServiceWithChannel, 'id'>;
 type IDocType = IWebAPI;
-type IModel = Model<IDocType, {}, {}, 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 = "ReserveInterface";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -2,9 +2,9 @@ import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from '
 import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Pick<factory.role.organizationRole.IRole, 'permissions' | 'roleName' | 'typeOf' | 'member' | 'memberOf'>;
-type IModel = Model<IDocType, {}, {}, 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 = "Role";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

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

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

package/lib/chevre/repo/mongoose/schemas/service/availableHour.d.ts

@@ -10,9 +10,9 @@ interface IOpeningHoursSpecification {
     validThrough: Date;
 }
 type IDocType = IOpeningHoursSpecification;
-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 = "Service.AvailableHour";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

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

@@ -183,9 +183,9 @@ export interface ISetting {
     useMongo4transactionNumberFrom?: Date;
 }
 type IDocType = ISetting;
-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 = "Setting";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

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

@@ -20,9 +20,9 @@ export interface ITicket {
     issuedBy: ITicketIssuedBy;
 }
 type IDocType = Omit<ITicket, '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 = "Ticket";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -4,9 +4,9 @@ import * as factory from '../../../factory';
 type IPlaceOrder = Omit<factory.transaction.placeOrder.ITransaction, 'id'>;
 type IReturnOrder = Omit<factory.transaction.returnOrder.ITransaction, 'id'>;
 type IDocType = IPlaceOrder | IReturnOrder;
-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 = "Transaction";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -32,9 +32,9 @@ interface IDataFeed {
     };
 }
 type IDocType = IDataFeed;
-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 = "TransactionNumber";
 declare function createSchema(): ISchema;
 export { createSchema, IDocType, IModel, modelName, DataCatalogIdentifier };

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

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

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

@@ -12,9 +12,7 @@ export declare class MovieTicketTypeRepo {
     private readonly categoryCodeModel;
     constructor(connection: Connection);
     static CREATE_MONGO_CONDITIONS(params: factory.movieTicketType.ISearchConditions): FilterQuery<IDocType>[];
-    static CREATE_AGGREGATE_PROJECTION(inclusion: IKeyOfProjection[]): {
-        [field: string]: AnyExpression;
-    };
+    static CREATE_AGGREGATE_PROJECTION(inclusion: IKeyOfProjection[]): Record<string, AnyExpression>;
     /**
      * 決済カード区分検索
      */

package/lib/chevre/repo/movieTicketType.js

@@ -203,7 +203,7 @@ class MovieTicketTypeRepo {
         let savedId;
         // let doc: HydratedDocument<{ _id: Types.ObjectId }> | null;
         if (typeof params.id !== 'string') {
-            const { id, $unset, ...creatingDoc } = params.attributes;
+            const { id, $unset, ...creatingDoc } = params.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
             const createResult = await this.categoryCodeModel.create(creatingDoc);
             // doc = createResult;
             if (typeof createResult.id !== 'string') {
@@ -213,7 +213,7 @@ class MovieTicketTypeRepo {
         }
         else {
             // 上書き禁止属性を除外(2022-08-24~)
-            const { id, codeValue, inCodeSet, project, typeOf, $unset, ...updateFields } = params.attributes;
+            const { id, codeValue, inCodeSet, project, typeOf, $unset, ...updateFields } = params.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
             const doc = await this.categoryCodeModel.findOneAndUpdate({ _id: { $eq: params.id } }, {
                 $set: updateFields,
                 ...($unset !== undefined) ? { $unset } : undefined

package/lib/chevre/repo/offer/offerInCatalogReadOnly.d.ts

@@ -1,8 +1,6 @@
 import * as factory from '../../factory';
 type KeyOfOffer = keyof Omit<factory.unitPriceOffer.IUnitPriceOffer, 'id'>;
-type IProjection = {
-    [key in KeyOfOffer]?: 0 | 1;
-};
+type IProjection = Partial<Record<KeyOfOffer, 0 | 1>>;
 type IOfferInCatalog = factory.unitPriceOffer.IUnitPriceOffer & {
     /**
      * 集計オファー内インデックス

package/lib/chevre/repo/offer/unitPriceInCatalog.d.ts

@@ -10,9 +10,7 @@ export declare class OfferRepo implements OfferInCatalogReadOnlyRepo {
     private readonly offerCatalogModel;
     private readonly offerCatalogItemModel;
     constructor(connection: Connection);
-    static CREATE_AGGREGATE_OFFERS_PROJECTION(params: IProjection): {
-        [field: string]: AnyExpression;
-    };
+    static CREATE_AGGREGATE_OFFERS_PROJECTION(params: IProjection): Record<string, AnyExpression>;
     /**
      * カタログIDで単価オファーを全て検索する
      * 必ずカタログデータから単価オファーIDを参照する

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

@@ -169,7 +169,7 @@ export declare class OfferCatalogRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
         _id: string;
         alternateName?: any;
         dateSynced?: Date;
@@ -177,7 +177,7 @@ export declare class OfferCatalogRepo {
         _id: string;
     }> & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
+    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
         _id: string;
         alternateName?: any;
         dateSynced?: Date;
@@ -185,7 +185,7 @@ export declare class OfferCatalogRepo {
         _id: string;
     }> & {
         __v: number;
-    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
+    }) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.offerCatalog.IOfferCatalog>;
         $unset: any;