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

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

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

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

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

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

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

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

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

package/lib/chevre/repo/message.js

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

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

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

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

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

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

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

package/lib/chevre/repo/mongoose/schemas/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>;
     /**
      * 所有者を追加する
      */