@chevre/domain 24.0.0-alpha.26 → 24.0.0-alpha.28

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

@@ -1,6 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-export interface IDocType extends factory.aggregateOffer.IAggregateOffer {
+export interface IDocType extends Omit<factory.aggregateOffer.IAggregateOffer, 'id'> {
     _id: string;
     includedInDataCatalog?: any[];
 }

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

@@ -7,4 +7,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "Authorization";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,10 +1,10 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.categoryCode.ICategoryCode;
+type IDocType = Omit<factory.categoryCode.ICategoryCode, 'id'>;
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
 type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "CategoryCode";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,6 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.creativeWork.movie.ICreativeWork & {
+type IDocType = Omit<factory.creativeWork.movie.ICreativeWork, 'id'> & {
     description?: string;
 };
 type IModel = Model<IDocType>;
@@ -9,4 +9,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "CreativeWork";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,10 +1,10 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.customer.ICustomer;
+type IDocType = Omit<factory.customer.ICustomer, 'id'>;
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
 type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Customer";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,11 +1,11 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
 export type ICustomerType = Pick<factory.categoryCode.ICategoryCode, 'codeValue' | 'id' | 'name' | 'typeOf'>;
-type IDocType = ICustomerType;
+type IDocType = Omit<ICustomerType, 'id'>;
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
 type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "CustomerType";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,6 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.eventOffer.IEventOffer;
+type IDocType = Omit<factory.eventOffer.IEventOffer, 'id'>;
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
 type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;

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

@@ -7,4 +7,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "Identity";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -7,4 +7,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "IdentityProvider";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,6 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-export type IDocType = factory.issuer.IIssuer & {
+export type IDocType = Omit<factory.issuer.IIssuer, 'id'> & {
     hasMemberProgram?: (factory.issuer.IMemberProgram & {
         hasTiers?: Pick<factory.issuer.IMemberProgramTier, 'identifier' | 'typeOf'>[];
     })[];

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

@@ -11,4 +11,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "Member.Global";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IGlobalMember, IModel, indexes, modelName };
+export { createSchema, IDocType, IGlobalMember, IModel, indexes, modelName };

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

@@ -15,11 +15,11 @@ export type IEmailMessage = factory.creativeWork.message.email.ICreativeWork & {
         typeOf: factory.organizationType.Corporation;
     };
 };
-type IDocType = IEmailMessage;
+type IDocType = Omit<IEmailMessage, 'id'>;
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
 type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Message";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,6 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.movieTicketType.IMovieTicketType;
+type IDocType = Omit<factory.movieTicketType.IMovieTicketType, 'id'>;
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
 type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;

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

@@ -1,6 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-export type IDocType = factory.offerCatalog.IOfferCatalog & {
+export type IDocType = Omit<factory.offerCatalog.IOfferCatalog, 'id'> & {
     _id: string;
     alternateName?: any;
     dateSynced?: Date;

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

@@ -1,6 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-export type IDocType = factory.offerCatalog.IOfferCatalog & {
+export type IDocType = Omit<factory.offerCatalog.IOfferCatalog, 'id'> & {
     _id: string;
     alternateName?: any;
     dateSynced?: Date;

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

@@ -1,10 +1,10 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.offerItemCondition.IOfferItemCondition;
+type IDocType = Omit<factory.offerItemCondition.IOfferItemCondition, 'id'>;
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
 type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "OfferItemCondition";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,6 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood> & {
+type IDocType = Omit<factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood>, 'id'> & {
     _id: string;
 };
 type IModel = Model<IDocType>;
@@ -9,4 +9,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "OwnershipInfo";
 declare function createSchema(): ISchema;
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -9,4 +9,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "PaymentService";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -7,4 +7,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "PaymentServiceChannel";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -7,4 +7,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "PotentialAction";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,6 +1,8 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-export type IDocType = factory.priceSpecification.IPriceSpecification<factory.priceSpecificationType> & {
+type ICategoryCodeChargeSpecification = Omit<factory.priceSpecification.IPriceSpecification<factory.priceSpecificationType.CategoryCodeChargeSpecification>, 'id'>;
+type IMovieTicketTypeChargeSpecification = Omit<factory.priceSpecification.IPriceSpecification<factory.priceSpecificationType.MovieTicketTypeChargeSpecification>, 'id'>;
+export type IDocType = (ICategoryCodeChargeSpecification | IMovieTicketTypeChargeSpecification) & {
     validFrom?: Date;
     validThrough?: Date;
 };

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

@@ -11,4 +11,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "Product";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IDocTypeAsProduct, IDocTypeAsProductOffer, IModel, indexes, modelName };
+export { createSchema, IDocType, IDocTypeAsProduct, IDocTypeAsProductOffer, IModel, indexes, modelName };

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

@@ -22,7 +22,7 @@ export interface IProductModel {
         }[];
     }[];
 }
-type IDocType = IProductModel;
+type IDocType = Omit<IProductModel, 'id'>;
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
 type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;

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

@@ -11,4 +11,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "Project";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,6 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.schedule.IEventWithSchedule;
+type IDocType = Omit<factory.schedule.IEventWithSchedule, 'id'>;
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
 type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;

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

@@ -7,4 +7,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "Seller";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -7,4 +7,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "SellerReturnPolicy";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,6 +1,6 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.permit.IPermit;
+type IDocType = Omit<factory.permit.IPermit, 'id'>;
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
 type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;

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

@@ -188,4 +188,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "Setting";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -7,4 +7,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "Task";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -25,4 +25,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "Ticket";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,10 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
-type IDocType = factory.transaction.ITransaction<factory.transactionType>;
+type IPlaceOrder = Omit<factory.transaction.placeOrder.ITransaction, 'id'>;
+type IReturnOrder = Omit<factory.transaction.returnOrder.ITransaction, 'id'>;
+type IMoneyTransfer = Omit<factory.transaction.moneyTransfer.ITransaction, 'id'>;
+type IDocType = IPlaceOrder | IReturnOrder | IMoneyTransfer;
 type IModel = Model<IDocType>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
 type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Transaction";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -7,4 +7,4 @@ type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocT
 declare const modelName = "WebSite";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -4,7 +4,7 @@ import * as factory from '../factory';
 type IUnset = {
     [key in keyof Pick<IDocType, 'color' | 'image'>]?: 1;
 };
-type IKeyOfProjection = keyof IDocType;
+type IKeyOfProjection = keyof IDocType | 'id';
 /**
  * 決済カード区分リポジトリ
  */
@@ -35,6 +35,7 @@ export declare class MovieTicketTypeRepo {
         id?: string;
         attributes: IDocType & {
             $unset?: IUnset;
+            id?: string;
         };
     }): Promise<{
         id: string;

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

@@ -1,5 +1,5 @@
 import type { BulkWriteResult } from 'mongodb';
-import type { Connection, Document, FilterQuery } from 'mongoose';
+import type { Connection, FilterQuery } from 'mongoose';
 import * as factory from '../factory';
 import { IDocType } from './mongoose/schemas/offerCatalog';
 export type IAggregatedOfferCatalog = Pick<factory.offerCatalog.IOfferCatalog, 'id' | 'name' | 'description' | 'project' | 'typeOf' | 'identifier' | 'itemOffered' | 'additionalProperty'> & {
@@ -169,19 +169,23 @@ export declare class OfferCatalogRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<Document<unknown, {}, IDocType> & factory.offerCatalog.IOfferCatalog & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
         _id: string;
         alternateName?: any;
         dateSynced?: Date;
     } & Required<{
         _id: string;
-    }>, import("mongoose").QueryOptions<Document<unknown, {}, IDocType> & factory.offerCatalog.IOfferCatalog & {
+    }> & {
+        __v: number;
+    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
         _id: string;
         alternateName?: any;
         dateSynced?: Date;
     } & Required<{
         _id: string;
-    }>>>;
+    }> & {
+        __v: number;
+    }) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.offerCatalog.IOfferCatalog>;
         $unset: any;

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

@@ -144,17 +144,23 @@ export declare class OrderRepo {
     })[]>;
     getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, Omit<factory.order.IOrder, "id"> & {
         acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
-    }> & Omit<factory.order.IOrder, "id"> & {
+    }, {}, {}> & Omit<factory.order.IOrder, "id"> & {
         acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }, import("mongoose").QueryOptions<import("mongoose").Document<unknown, {}, Omit<factory.order.IOrder, "id"> & {
+    } & {
+        __v: number;
+    }, import("mongoose").QueryOptions<Omit<factory.order.IOrder, "id"> & {
+        acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
+    }>, (import("mongoose").Document<unknown, {}, Omit<factory.order.IOrder, "id"> & {
         acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
-    }> & Omit<factory.order.IOrder, "id"> & {
+    }, {}, {}> & Omit<factory.order.IOrder, "id"> & {
         acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }>>;
+    } & {
+        __v: number;
+    }) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.order.IOrder>;
         $unset: any;

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

@@ -1,4 +1,5 @@
 import type { Connection } from 'mongoose';
+import { IDocType } from './mongoose/schemas/ownershipInfo';
 import * as factory from '../factory';
 export type IOwnershipInfoWithId = factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood> & {
     id: string;
@@ -73,19 +74,19 @@ export declare class OwnershipInfoRepo {
             $lt: Date;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood> & {
-        _id: string;
-    }> & factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood> & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood>, "id"> & {
         _id: string;
     } & Required<{
         _id: string;
-    }>, import("mongoose").QueryOptions<import("mongoose").Document<unknown, {}, factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood> & {
-        _id: string;
-    }> & factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood> & {
+    }> & {
+        __v: number;
+    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood>, "id"> & {
         _id: string;
     } & Required<{
         _id: string;
-    }>>>;
+    }> & {
+        __v: number;
+    }) | null>;
     /**
      * 所有者を追加する
      */

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

@@ -1,6 +1,6 @@
 import type { Connection, FilterQuery } from 'mongoose';
 import * as factory from '../factory';
-import { IModel } from './mongoose/schemas/paymentService';
+import { IModel, IDocType } from './mongoose/schemas/paymentService';
 type IUnsetKey = keyof Pick<factory.service.paymentService.IService, 'additionalProperty' | 'availableChannel' | 'serviceOutput' | 'serviceType'>;
 type IKeyOfProjection4paymentService = keyof factory.service.paymentService.IService;
 /**
@@ -73,19 +73,19 @@ export declare class PaymentServiceRepo {
         filter: any;
         $unset: any;
     }): Promise<import("mongoose").UpdateWriteOpResult>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, Omit<import("@chevre/factory/lib/service/paymentService").IService, "id"> & {
-        provider?: factory.service.paymentService.IProvider[];
-    }> & Omit<import("@chevre/factory/lib/service/paymentService").IService, "id"> & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/service/paymentService").IService, "id"> & {
         provider?: factory.service.paymentService.IProvider[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }, import("mongoose").QueryOptions<import("mongoose").Document<unknown, {}, Omit<import("@chevre/factory/lib/service/paymentService").IService, "id"> & {
-        provider?: factory.service.paymentService.IProvider[];
-    }> & Omit<import("@chevre/factory/lib/service/paymentService").IService, "id"> & {
+    } & {
+        __v: number;
+    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/service/paymentService").IService, "id"> & {
         provider?: factory.service.paymentService.IProvider[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }>>;
+    } & {
+        __v: number;
+    }) | null>;
     getModel(): IModel;
 }
 export {};

package/lib/chevre/repo/place/movieTheater.d.ts

@@ -95,15 +95,19 @@ export declare class MovieTheaterRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType> & Omit<import("@chevre/factory/lib/place/movieTheater").IPlace, "id"> & {
+    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/place/movieTheater").IPlace, "id"> & {
         hasPOS?: factory.place.movieTheater.IPOS[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }, import("mongoose").QueryOptions<import("mongoose").Document<unknown, {}, IDocType> & Omit<import("@chevre/factory/lib/place/movieTheater").IPlace, "id"> & {
+    } & {
+        __v: number;
+    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/place/movieTheater").IPlace, "id"> & {
         hasPOS?: factory.place.movieTheater.IPOS[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }>>;
+    } & {
+        __v: number;
+    }) | null>;
     unsetUnnecessaryFields(params: {
         filter: any;
         $unset: any;

package/lib/chevre/repo/place/screeningRoom.d.ts

@@ -124,7 +124,7 @@ export declare class ScreeningRoomRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType> & Omit<import("@chevre/factory/lib/place/screeningRoom").IPlace, "containsPlace"> & {
+    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/place/screeningRoom").IPlace, "containsPlace"> & {
         description?: any;
         openingHoursSpecification?: any;
         smokingAllowed?: boolean;
@@ -133,7 +133,9 @@ export declare class ScreeningRoomRepo {
         })[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }, import("mongoose").QueryOptions<import("mongoose").Document<unknown, {}, IDocType> & Omit<import("@chevre/factory/lib/place/screeningRoom").IPlace, "containsPlace"> & {
+    } & {
+        __v: number;
+    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & Omit<import("@chevre/factory/lib/place/screeningRoom").IPlace, "containsPlace"> & {
         description?: any;
         openingHoursSpecification?: any;
         smokingAllowed?: boolean;
@@ -142,6 +144,8 @@ export declare class ScreeningRoomRepo {
         })[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }>>;
+    } & {
+        __v: number;
+    }) | null>;
 }
 export {};

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

@@ -1,5 +1,6 @@
 import { Connection, FilterQuery, QueryOptions } from 'mongoose';
 import * as factory from '../factory';
+import { IDocType } from './mongoose/schemas/potentialAction';
 export type ISavingPotentialAction = Pick<factory.potentialAction.IPotentialAction, 'target' | 'project' | 'typeOf' | 'identifier'> & {
     id?: never;
 };
@@ -23,34 +24,14 @@ export declare class PotentialActionRepo {
         id: string;
     }>;
     projectFields(conditions: factory.potentialAction.ISearchConditions, inclusion: IKeyOfProjection[]): Promise<factory.potentialAction.IPotentialAction[]>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, {
-        project: Pick<factory.project.IProject, "id" | "typeOf">;
-        identifier: string;
-        typeOf: factory.actionType.InformAction;
-        recipient: factory.potentialAction.IInformRecipient;
-        target: factory.entryPoint.IEntryPoint;
-    }> & {
-        project: Pick<factory.project.IProject, "id" | "typeOf">;
-        identifier: string;
-        typeOf: factory.actionType.InformAction;
-        recipient: factory.potentialAction.IInformRecipient;
-        target: factory.entryPoint.IEntryPoint;
-    } & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, {}, {}> & IDocType & {
         _id: import("mongoose").Types.ObjectId;
-    }, QueryOptions<import("mongoose").Document<unknown, {}, {
-        project: Pick<factory.project.IProject, "id" | "typeOf">;
-        identifier: string;
-        typeOf: factory.actionType.InformAction;
-        recipient: factory.potentialAction.IInformRecipient;
-        target: factory.entryPoint.IEntryPoint;
-    }> & {
-        project: Pick<factory.project.IProject, "id" | "typeOf">;
-        identifier: string;
-        typeOf: factory.actionType.InformAction;
-        recipient: factory.potentialAction.IInformRecipient;
-        target: factory.entryPoint.IEntryPoint;
     } & {
+        __v: number;
+    }, QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, {}, {}> & IDocType & {
         _id: import("mongoose").Types.ObjectId;
-    }>>;
+    } & {
+        __v: number;
+    }) | null>;
 }
 export {};