@chevre/domain 15.65.0-alpha.9 → 20.0.0-alpha.1

package/lib/chevre/repo/mongoose/model/order.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = exports.modelName = void 0;
+const mongoose = require("mongoose");
+const modelName = 'Order';
+exports.modelName = modelName;
+const writeConcern = { j: true, w: 'majority', wtimeout: 10000 };
+/**
+ * 注文スキーマ
+ */
+const schema = new mongoose.Schema({
+    broker: mongoose.SchemaTypes.Mixed,
+    project: mongoose.SchemaTypes.Mixed,
+    typeOf: {
+        type: String,
+        required: true
+    },
+    identifier: [mongoose.SchemaTypes.Mixed],
+    name: String,
+    seller: mongoose.SchemaTypes.Mixed,
+    customer: mongoose.SchemaTypes.Mixed,
+    returner: mongoose.SchemaTypes.Mixed,
+    confirmationNumber: String,
+    orderNumber: String,
+    price: Number,
+    priceCurrency: String,
+    acceptedOffers: [mongoose.SchemaTypes.Mixed],
+    paymentMethods: [mongoose.SchemaTypes.Mixed],
+    discounts: [mongoose.SchemaTypes.Mixed],
+    url: String,
+    orderStatus: String,
+    orderDate: Date,
+    isGift: Boolean,
+    dateReturned: Date,
+    // ↓追加(2022-04-15~)
+    orderedItem: [mongoose.SchemaTypes.Mixed]
+}, {
+    collection: 'orders',
+    id: true,
+    read: 'primaryPreferred',
+    writeConcern: writeConcern,
+    strict: true,
+    useNestedStrict: true,
+    timestamps: {
+        createdAt: 'createdAt',
+        updatedAt: 'updatedAt'
+    },
+    toJSON: {
+        getters: false,
+        virtuals: false,
+        minimize: false,
+        versionKey: false
+    },
+    toObject: {
+        getters: false,
+        virtuals: true,
+        minimize: false,
+        versionKey: false
+    }
+});
+exports.schema = schema;
+schema.index({ createdAt: 1 }, { name: 'searchByCreatedAt' });
+schema.index({ updatedAt: 1 }, { name: 'searchByUpdatedAt' });
+schema.index({ 'project.id': 1, orderDate: -1 }, {
+    name: 'searchByProjectId-v20220721'
+});
+schema.index({ identifier: 1, orderDate: -1 }, {
+    name: 'searchByIdentifier',
+    partialFilterExpression: {
+        identifier: { $exists: true }
+    }
+});
+// 注文番号はユニークなはず
+schema.index({ orderNumber: 1 }, {
+    unique: true,
+    name: 'uniqueOrderNumber'
+});
+schema.index({ 'seller.typeOf': 1, orderDate: -1 }, {
+    name: 'searchBySellerTypeOf',
+    partialFilterExpression: {
+        'seller.typeOf': { $exists: true }
+    }
+});
+schema.index({ 'seller.id': 1, orderDate: -1 }, {
+    name: 'searchOrdersBySellerAndOrderDate',
+    partialFilterExpression: {
+        'seller.id': { $exists: true }
+    }
+});
+schema.index({ orderDate: -1 }, {
+    name: 'searchByOrderDate'
+});
+schema.index({ orderStatus: 1, orderDate: -1 }, {
+    name: 'searchOrdersByOrderStatusAndOrderDate'
+});
+schema.index({ 'broker.id': 1, orderDate: -1 }, {
+    name: 'searchByBrokerId',
+    partialFilterExpression: {
+        'broker.id': { $exists: true }
+    }
+});
+schema.index({ confirmationNumber: 1, orderDate: -1 }, {
+    name: 'searchOrdersByConfirmationNumberAndOrderDate',
+    partialFilterExpression: {
+        confirmationNumber: { $exists: true }
+    }
+});
+schema.index({ 'customer.typeOf': 1, orderDate: -1 }, {
+    name: 'searchByCustomerTypeOfAndOrderDate',
+    partialFilterExpression: {
+        'customer.typeOf': { $exists: true }
+    }
+});
+schema.index({ 'customer.id': 1, orderDate: -1 }, {
+    name: 'searchByCustomerIdAndOrderDate',
+    partialFilterExpression: {
+        'customer.id': { $exists: true }
+    }
+});
+schema.index({ 'customer.identifier': 1, orderDate: -1 }, {
+    name: 'searchByCustomerIdentifierAndOrderDate',
+    partialFilterExpression: {
+        'customer.identifier': { $exists: true }
+    }
+});
+schema.index({ 'customer.additionalProperty': 1, orderDate: -1 }, {
+    name: 'searchByCustomerAdditionalProperty',
+    partialFilterExpression: {
+        'customer.additionalProperty': { $exists: true }
+    }
+});
+schema.index({ 'customer.memberOf.membershipNumber': 1, orderDate: -1 }, {
+    name: 'searchByCustomerMemberhipNumberAndOrderDate',
+    partialFilterExpression: {
+        'customer.memberOf.membershipNumber': { $exists: true }
+    }
+});
+schema.index({ 'customer.givenName': 1, orderDate: -1 }, {
+    name: 'searchByCustomerGivenNameAndOrderDate',
+    partialFilterExpression: {
+        'customer.givenName': { $exists: true }
+    }
+});
+schema.index({ 'customer.familyName': 1, orderDate: -1 }, {
+    name: 'searchByCustomerFamilyNameAndOrderDate',
+    partialFilterExpression: {
+        'customer.familyName': { $exists: true }
+    }
+});
+schema.index({ 'customer.email': 1, orderDate: -1 }, {
+    name: 'searchByCustomerEmailAndOrderDate',
+    partialFilterExpression: {
+        'customer.email': { $exists: true }
+    }
+});
+schema.index({ 'customer.telephone': 1, orderDate: -1 }, {
+    name: 'searchByCustomerTelephoneAndOrderDate',
+    partialFilterExpression: {
+        'customer.telephone': { $exists: true }
+    }
+});
+schema.index({ name: 1, orderDate: -1 }, {
+    name: 'searchByName',
+    partialFilterExpression: {
+        name: { $exists: true }
+    }
+});
+schema.index({ 'paymentMethods.accountId': 1, orderDate: -1 }, {
+    name: 'searchByPaymentMethodsAccountId',
+    partialFilterExpression: {
+        'paymentMethods.accountId': { $exists: true }
+    }
+});
+schema.index({ 'paymentMethods.additionalProperty': 1, orderDate: -1 }, {
+    name: 'searchBypaymentMethodsAdditionalProperty',
+    partialFilterExpression: {
+        'paymentMethods.additionalProperty': { $exists: true }
+    }
+});
+schema.index({ 'paymentMethods.typeOf': 1, orderDate: -1 }, {
+    name: 'searchByPaymentMethodTypeAndOrderDate',
+    partialFilterExpression: {
+        'paymentMethods.typeOf': { $exists: true }
+    }
+});
+schema.index({ 'paymentMethods.paymentMethodId': 1, orderDate: -1 }, {
+    name: 'searchByPaymentMethodIdAndOrderDate',
+    partialFilterExpression: {
+        'paymentMethods.paymentMethodId': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.typeOf': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedTypeOf',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.typeOf': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.identifier': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedIdentifier',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.identifier': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.id': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedIdAndOrderDate',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.id': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.issuedThrough.typeOf': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedIssuedThroughTypeOf',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.issuedThrough.typeOf': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.issuedThrough.id': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedIssuedThroughId',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.issuedThrough.id': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.programMembershipUsed.identifier': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedProgramMembershipUsedIdentifier',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.programMembershipUsed.identifier': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.programMembershipUsed.issuedThrough.serviceType.codeValue': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedMembershipUsedServiceType',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.programMembershipUsed.issuedThrough.serviceType.codeValue': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.reservationNumber': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedReservationNumberAndOrderDate',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.reservationNumber': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.reservationFor.id': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedReservationForIdAndOrderDate',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.reservationFor.id': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.reservationFor.identifier': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedReservationForIdentifierAndOrderDate',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.reservationFor.identifier': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.reservationFor.name': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedReservationForNameAndOrderDate',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.reservationFor.name': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.reservationFor.endDate': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedReservationForEndDateAndOrderDate',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.reservationFor.endDate': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.reservationFor.startDate': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedReservationForStartDateAndOrderDate',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.reservationFor.startDate': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.reservationFor.location.branchCode': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedReservationForLocationBranchCodeAndOrderDate',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.reservationFor.location.branchCode': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.reservationFor.superEvent.id': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedReservationForLocationSuperEventIdAndOrderDate',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.reservationFor.superEvent.id': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.reservationFor.superEvent.location.branchCode': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedReservationForLocationSuperEventLocationBranchCodeAndOrderDate',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.reservationFor.superEvent.location.branchCode': { $exists: true }
+    }
+});
+schema.index({ 'acceptedOffers.itemOffered.reservationFor.superEvent.workPerformed.identifier': 1, orderDate: -1 }, {
+    name: 'searchByItemOfferedReservationForLocationSuperEventWorkPerformedIdentifierAndOrderDate',
+    partialFilterExpression: {
+        'acceptedOffers.itemOffered.reservationFor.superEvent.workPerformed.identifier': { $exists: true }
+    }
+});
+schema.index({ price: 1, orderDate: -1 }, {
+    name: 'searchByPrice',
+    partialFilterExpression: {
+        price: { $exists: true }
+    }
+});
+mongoose.model(modelName, schema)
+    .on('index', 
+// tslint:disable-next-line:no-single-line-block-comment
+/* istanbul ignore next */
+(error) => {
+    if (error !== undefined) {
+        // tslint:disable-next-line:no-console
+        console.error(error);
+    }
+});

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

@@ -0,0 +1,7 @@
+import * as mongoose from 'mongoose';
+declare const modelName = "OwnershipInfo";
+/**
+ * 所有権スキーマ
+ */
+declare const schema: mongoose.Schema<mongoose.Document<any, any, any>, mongoose.Model<mongoose.Document<any, any, any>, any, any>, undefined, {}>;
+export { modelName, schema };

package/lib/chevre/repo/mongoose/model/ownershipInfo.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = exports.modelName = void 0;
+const mongoose = require("mongoose");
+const modelName = 'OwnershipInfo';
+exports.modelName = modelName;
+const writeConcern = { j: true, w: 'majority', wtimeout: 10000 };
+// Arrayにも対応するためにMixedに変更(2022-07-26~)
+const ownedBySchema = mongoose.SchemaTypes.Mixed;
+const acquiredFromSchema = new mongoose.Schema({}, {
+    id: false,
+    _id: false,
+    strict: false
+});
+const typeOfGoodSchema = new mongoose.Schema({}, {
+    id: false,
+    _id: false,
+    strict: false
+});
+/**
+ * 所有権スキーマ
+ */
+const schema = new mongoose.Schema({
+    project: mongoose.SchemaTypes.Mixed,
+    _id: String,
+    typeOf: {
+        type: String,
+        required: true
+    },
+    identifier: mongoose.SchemaTypes.Mixed,
+    ownedBy: ownedBySchema,
+    acquiredFrom: acquiredFromSchema,
+    ownedFrom: Date,
+    ownedThrough: Date,
+    typeOfGood: typeOfGoodSchema
+}, {
+    collection: 'ownershipInfos',
+    id: true,
+    read: 'primaryPreferred',
+    writeConcern: writeConcern,
+    strict: true,
+    useNestedStrict: true,
+    timestamps: {
+        createdAt: 'createdAt',
+        updatedAt: 'updatedAt'
+    },
+    toJSON: {
+        getters: false,
+        virtuals: false,
+        minimize: false,
+        versionKey: false
+    },
+    toObject: {
+        getters: false,
+        virtuals: true,
+        minimize: false,
+        versionKey: false
+    }
+});
+exports.schema = schema;
+schema.index({ createdAt: 1 }, { name: 'searchByCreatedAt' });
+schema.index({ updatedAt: 1 }, { name: 'searchByUpdatedAt' });
+// 識別子はユニークな前提
+schema.index({ identifier: 1 }, {
+    unique: true,
+    name: 'uniqueIdentifier'
+});
+schema.index({ ownedFrom: -1 }, { name: 'searchByOwnedFrom-v3' });
+schema.index({ 'project.id': 1, ownedFrom: -1 }, {
+    name: 'searchByProjectId-v20220721'
+});
+schema.index({ typeOf: 1, ownedFrom: -1 }, { name: 'searchByTypeOf-v2' });
+schema.index({ identifier: 1, ownedFrom: -1 }, {
+    name: 'searchByIdentifier-v2',
+    partialFilterExpression: {
+        identifier: { $exists: true }
+    }
+});
+schema.index({ 'acquiredFrom.id': 1, ownedFrom: -1 }, {
+    name: 'searchByAcquiredFromId-v2',
+    partialFilterExpression: {
+        'acquiredFrom.id': { $exists: true }
+    }
+});
+schema.index({ 'ownedBy.typeOf': 1, ownedFrom: -1 }, {
+    name: 'searchByOwnedByTypeOf',
+    partialFilterExpression: {
+        'ownedBy.typeOf': { $exists: true }
+    }
+});
+schema.index({ 'ownedBy.id': 1, ownedFrom: -1 }, {
+    name: 'searchByOwnedById',
+    partialFilterExpression: {
+        'ownedBy.id': { $exists: true }
+    }
+});
+schema.index({ 'ownedBy.memberOf.membershipNumber': 1, ownedFrom: -1 }, {
+    name: 'searchByOwnedByMemberOfMembershipNumber',
+    partialFilterExpression: {
+        'ownedBy.memberOf.membershipNumber': { $exists: true }
+    }
+});
+schema.index({ ownedThrough: -1, ownedFrom: -1 }, {
+    name: 'searchByOwnedThrough-v2',
+    partialFilterExpression: {
+        ownedThrough: { $exists: true }
+    }
+});
+schema.index({ 'typeOfGood.typeOf': 1, ownedFrom: -1 }, {
+    name: 'searchByTypeOfGoodTypeOf-v2',
+    partialFilterExpression: {
+        'typeOfGood.typeOf': { $exists: true }
+    }
+});
+schema.index({ 'typeOfGood.reservedTicket.ticketToken': 1, ownedFrom: -1 }, {
+    name: 'searchByTypeOfGoofReservedTicketToken',
+    partialFilterExpression: {
+        'typeOfGood.reservedTicket.ticketToken': { $exists: true }
+    }
+});
+schema.index({ 'typeOfGood.id': 1, ownedFrom: -1 }, {
+    name: 'searchByTypeOfGoodId',
+    partialFilterExpression: {
+        'typeOfGood.id': { $exists: true }
+    }
+});
+schema.index({ 'typeOfGood.identifier': 1, ownedFrom: -1 }, {
+    name: 'searchByTypeOfGoodIdentifier',
+    partialFilterExpression: {
+        'typeOfGood.identifier': { $exists: true }
+    }
+});
+schema.index({ 'typeOfGood.membershipFor.id': 1, ownedFrom: -1 }, {
+    name: 'searchByTypeOfGoodMembershipForId',
+    partialFilterExpression: {
+        'typeOfGood.membershipFor.id': { $exists: true }
+    }
+});
+schema.index({ 'typeOfGood.issuedThrough.id': 1, ownedFrom: -1 }, {
+    name: 'searchByTypeOfGoodIssuedThroughId',
+    partialFilterExpression: {
+        'typeOfGood.issuedThrough.id': { $exists: true }
+    }
+});
+schema.index({ 'typeOfGood.issuedThrough.typeOf': 1, ownedFrom: -1 }, {
+    name: 'searchByTypeOfGoodIssuedThroughTypeOf',
+    partialFilterExpression: {
+        'typeOfGood.issuedThrough.typeOf': { $exists: true }
+    }
+});
+schema.index({ 'typeOfGood.accountNumber': 1, ownedFrom: -1 }, {
+    name: 'searchByTypeOfGoodAccountNumber',
+    partialFilterExpression: {
+        'typeOfGood.accountNumber': { $exists: true }
+    }
+});
+schema.index({ 'typeOfGood.reservationNumber': 1, ownedFrom: -1 }, {
+    name: 'searchByTypeOfGoodReservationNumber',
+    partialFilterExpression: {
+        'typeOfGood.reservationNumber': { $exists: true }
+    }
+});
+mongoose.model(modelName, schema)
+    .on('index', 
+// tslint:disable-next-line:no-single-line-block-comment
+/* istanbul ignore next */
+(error) => {
+    if (error !== undefined) {
+        // tslint:disable-next-line:no-console
+        console.error(error);
+    }
+});

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

@@ -0,0 +1,7 @@
+import * as mongoose from 'mongoose';
+declare const modelName = "Place";
+/**
+ * 場所スキーマ
+ */
+declare const schema: mongoose.Schema<mongoose.Document<any, any, any>, mongoose.Model<mongoose.Document<any, any, any>, any, any>, undefined, {}>;
+export { modelName, schema };

package/lib/chevre/repo/mongoose/model/place.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = exports.modelName = void 0;
+const mongoose = require("mongoose");
+const modelName = 'Place';
+exports.modelName = modelName;
+const writeConcern = { j: true, w: 'majority', wtimeout: 10000 };
+/**
+ * 場所スキーマ
+ */
+const schema = new mongoose.Schema({
+    project: mongoose.SchemaTypes.Mixed,
+    typeOf: {
+        type: String,
+        required: true
+    },
+    name: mongoose.SchemaTypes.Mixed,
+    alternateName: mongoose.SchemaTypes.Mixed,
+    description: mongoose.SchemaTypes.Mixed,
+    address: mongoose.SchemaTypes.Mixed,
+    branchCode: String,
+    containedInPlace: mongoose.SchemaTypes.Mixed,
+    containsPlace: [mongoose.SchemaTypes.Mixed],
+    hasEntranceGate: [mongoose.SchemaTypes.Mixed],
+    hasPOS: [mongoose.SchemaTypes.Mixed],
+    maximumAttendeeCapacity: Number,
+    openingHoursSpecification: mongoose.SchemaTypes.Mixed,
+    smokingAllowed: Boolean,
+    telephone: String,
+    sameAs: String,
+    url: String,
+    kanaName: String,
+    offers: mongoose.SchemaTypes.Mixed,
+    additionalProperty: [mongoose.SchemaTypes.Mixed],
+    parentOrganization: mongoose.SchemaTypes.Mixed
+}, {
+    collection: 'places',
+    id: true,
+    read: 'primaryPreferred',
+    writeConcern: writeConcern,
+    strict: true,
+    useNestedStrict: true,
+    timestamps: {
+        createdAt: 'createdAt',
+        updatedAt: 'updatedAt'
+    },
+    toJSON: {
+        getters: false,
+        virtuals: false,
+        minimize: false,
+        versionKey: false
+    },
+    toObject: {
+        getters: false,
+        virtuals: true,
+        minimize: false,
+        versionKey: false
+    }
+});
+exports.schema = schema;
+schema.index({ createdAt: 1 }, { name: 'searchByCreatedAt' });
+schema.index({ updatedAt: 1 }, { name: 'searchByUpdatedAt' });
+schema.index({ branchCode: 1 }, { name: 'searchByBranchCode-v2' });
+schema.index({ typeOf: 1, branchCode: 1 }, { name: 'searchByTypeOf-v2' });
+schema.index({ 'project.id': 1, branchCode: 1 }, {
+    name: 'searchByProjectId-v20220721'
+});
+schema.index({ 'name.ja': 1, branchCode: 1 }, {
+    name: 'searchByNameJa',
+    partialFilterExpression: {
+        'name.ja': { $exists: true }
+    }
+});
+schema.index({ 'name.en': 1, branchCode: 1 }, {
+    name: 'searchByNameEn',
+    partialFilterExpression: {
+        'name.en': { $exists: true }
+    }
+});
+schema.index({ kanaName: 1, branchCode: 1 }, {
+    name: 'searchByKanaName-v2',
+    partialFilterExpression: {
+        kanaName: { $exists: true }
+    }
+});
+schema.index({ 'parentOrganization.id': 1, branchCode: 1 }, {
+    name: 'searchByParentOrganization',
+    partialFilterExpression: {
+        'parentOrganization.id': { $exists: true }
+    }
+});
+mongoose.model(modelName, schema)
+    .on('index', 
+// tslint:disable-next-line:no-single-line-block-comment
+/* istanbul ignore next */
+(error) => {
+    if (error !== undefined) {
+        // tslint:disable-next-line:no-console
+        console.error(error);
+    }
+});

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

@@ -0,0 +1,7 @@
+import * as mongoose from 'mongoose';
+declare const modelName = "PriceSpecification";
+/**
+ * 価格仕様スキーマ
+ */
+declare const schema: mongoose.Schema<mongoose.Document<any, any, any>, mongoose.Model<mongoose.Document<any, any, any>, any, any>, undefined, {}>;
+export { modelName, schema };