@chevre/domain 21.18.0-alpha.4 → 21.18.0-alpha.41

package/example/src/chevre/aggreateOwnershipInfosByOrder.ts

@@ -0,0 +1,24 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const acceptedOfferRepo = await chevre.repository.AcceptedOffer.createInstance(mongoose.connection);
+
+    const ownershipInfos = await acceptedOfferRepo.aggreateOwnershipInfosByOrder(
+        {
+            orderNumber: { $eq: 'CIN4-3943271-4221863' }
+        }
+    );
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(ownershipInfos, { depth: 1 });
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/offerCatalog2offerCatalogItem.ts

@@ -21,6 +21,7 @@ async function main() {
     let i = 0;
     let maxOfferCatalogItemNumItemListElement = 0;
     let maxIdentifierLength = 0;
+    let maxOfferCatalogItemLength = 0;
     for (const offerCatalog of offerCatalogs) {
         i += 1;
         maxIdentifierLength = Math.max(maxIdentifierLength, offerCatalog.identifier.length);
@@ -145,11 +146,14 @@ async function main() {
             maxOfferCatalogItemNumItemListElement =
                 Math.max(maxOfferCatalogItemNumItemListElement, offerCatalogItem.itemListElement.length);
         });
+
+        maxOfferCatalogItemLength = Math.max(maxOfferCatalogItemLength, offerCatalogItems.length);
     }
 
     console.log(i, 'offerCatalogs checked');
     console.log('maxOfferCatalogItemNumItemListElement:', maxOfferCatalogItemNumItemListElement);
     console.log('maxIdentifierLength:', maxIdentifierLength);
+    console.log('maxOfferCatalogItemLength:', maxOfferCatalogItemLength);
 }
 
 main()

package/example/src/chevre/searchAcceptedOfferIds.ts

@@ -0,0 +1,57 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const acceptedOfferRepo = await chevre.repository.AcceptedOffer.createInstance(mongoose.connection);
+
+    let offerIds: string[];
+
+    // const searchConditions: chevre.factory.order.ISearchConditions = {
+    //     limit: 10,
+    //     page: 1,
+    //     project: { id: { $eq: project.id } },
+    //     orderNumbers: ['CIN1-3743286-2441943', 'CIN4-3943511-3323473'],
+    //     acceptedOffers: { itemOffered: { typeOf: { $in: [chevre.factory.reservationType.EventReservation] } } }
+    // };
+    // let offerIds = await acceptedOfferRepo.__searchAcceptedOfferIds(searchConditions);
+    // console.log(offerIds);
+    offerIds = await acceptedOfferRepo.distinctValues(
+        { orderNumber: { $in: ['CIN1-3743286-2441943', 'CIN4-3943511-3323473'] } },
+        'acceptedOffers.id'
+    );
+    console.log(offerIds);
+
+    const productIds = await acceptedOfferRepo.distinctValues(
+        { orderNumber: { $in: ['CIN1-3743286-2441943', 'CIN4-3943511-3323473'] } },
+        'acceptedOffers.itemOffered.issuedThrough.id'
+    );
+    console.log(productIds);
+
+    const locationBranchCodes = await acceptedOfferRepo.distinctValues(
+        { orderNumber: { $in: ['CIN1-3743286-2441943', 'CIN4-3943511-3323473'] } },
+        'acceptedOffers.itemOffered.reservationFor.superEvent.location.branchCode'
+    );
+    console.log(locationBranchCodes);
+
+    const offeredThroughIdentifiers = await acceptedOfferRepo.distinctValues(
+        { orderNumber: { $in: ['CIN1-3743286-2441943', 'CIN4-3943511-3323473'] } },
+        'acceptedOffers.offeredThrough.identifier'
+    );
+    console.log(offeredThroughIdentifiers);
+
+    const invalidValues = await acceptedOfferRepo.distinctValues(
+        { orderNumber: { $in: ['CIN1-3743286-2441943', 'CIN4-3943511-3323473'] } },
+        <any>'invalidValues'
+    );
+    console.log(invalidValues);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/searchOffers.ts

@@ -10,52 +10,56 @@ mongoose.Model.on('index', (...args) => {
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI);
 
-    const indexes = await mongoose.connection.db.collection('aggregateOffers')
-        .indexes();
-    console.log(indexes);
-    console.log(indexes.length);
+    // const indexes = await mongoose.connection.db.collection('aggregateOffers')
+    //     .indexes();
+    // console.log(indexes);
+    // console.log(indexes.length);
 
     const offerRepo = await chevre.repository.Offer.createInstance(mongoose.connection);
 
-    const offers = await offerRepo.search({
-        limit: 100,
-        // page: 1,
-        project: { id: { $eq: String(process.env.PROJECT_ID) } },
-        availability: { $eq: chevre.factory.itemAvailability.InStock },
-        acceptedPaymentMethod: { identifier: { $in: ['xxx'] } },
-        parentOffer: {
-        },
-        priceSpecification: {
-            appliesToMovieTicket: {
-                serviceOutput: {
-                    typeOf: {
-                        // $eq: '',
-                        // $all: []
+    const offers = await offerRepo.search(
+        {
+            limit: 100,
+            // page: 1,
+            project: { id: { $eq: String(process.env.PROJECT_ID) } },
+            availability: { $eq: chevre.factory.itemAvailability.InStock },
+            // acceptedPaymentMethod: { identifier: { $in: ['xxx'] } },
+            parentOffer: {
+            },
+            priceSpecification: {
+                appliesToMovieTicket: {
+                    serviceOutput: {
+                        typeOf: {
+                            // $eq: '',
+                            // $all: []
+                        }
                     }
                 }
             }
+            // includedInDataCatalog: { id: { $in: ['0001'] } }
+            // additionalProperty: {
+            //     $all: [
+            //         {
+            //             $elemMatch: {
+            //                 name: { $eq: 'theaterCode' },
+            //                 value: { $in: ['120'] }
+            //             }
+            //         },
+            //         {
+            //             $elemMatch: {
+            //                 name: { $eq: 'ticketCode' },
+            //                 value: { $in: ['10', '1001'] }
+            //             }
+            //         }
+            //     ]
+            // }
         }
-        // includedInDataCatalog: { id: { $in: ['0001'] } }
-        // additionalProperty: {
-        //     $all: [
-        //         {
-        //             $elemMatch: {
-        //                 name: { $eq: 'theaterCode' },
-        //                 value: { $in: ['120'] }
-        //             }
-        //         },
-        //         {
-        //             $elemMatch: {
-        //                 name: { $eq: 'ticketCode' },
-        //                 value: { $in: ['10', '1001'] }
-        //             }
-        //         }
-        //     ]
-        // }
-    });
+        // { identifier: 1 }
+    );
     console.log(offers.map((offer) => {
-        return `${offer.project.id} ${offer.id} ${offer.identifier} ${offer.name.ja}`;
+        return `${offer.project?.id} ${offer.id} ${offer.parentOffer?.id} ${offer.identifier} ${offer.name?.ja}`;
     }));
+    // console.log(offers);
     console.log(offers.length);
 }
 

package/example/src/chevre/searchOrderAcceptedOffers.ts

@@ -8,19 +8,19 @@ const project = { id: String(process.env.PROJECT_ID) };
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI);
 
-    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+    const acceptedOfferRepo = await chevre.repository.AcceptedOffer.createInstance(mongoose.connection);
 
-    const searchConditions: chevre.factory.order.ISearchConditions = {
-        // tslint:disable-next-line:no-magic-numbers
-        limit: 10,
-        page: 1,
-        project: { id: { $eq: project.id } },
-        confirmationNumbers: ['36684'],
-        orderNumbers: ['CIN1-3743286-2441943'],
-        acceptedOffers: { itemOffered: { typeOf: { $in: [chevre.factory.reservationType.EventReservation] } } }
-        // ...(typeof req.seller?.id === 'string') ? { seller: { id: { $eq: req.seller.id } } } : undefined // req.seller.idを考慮
-    };
-    const acceptedOffers = await orderRepo.searchAcceptedOffers(searchConditions, ['itemOffered', 'id']);
+    const acceptedOffers = await acceptedOfferRepo.searchAcceptedOffersByOrderNumber(
+        {
+            // tslint:disable-next-line:no-magic-numbers
+            limit: 10,
+            page: 1,
+            project: { id: { $eq: project.id } },
+            orderNumber: { $eq: 'CIN3-0760465-8981560' },
+            acceptedOffers: { itemOffered: { typeOf: { $in: [chevre.factory.reservationType.EventReservation] } } }
+        },
+        ['itemOffered', 'id']
+    );
     // tslint:disable-next-line:no-null-keyword
     console.dir(acceptedOffers, { depth: 1 });
     const reservationIds = acceptedOffers.map((acceptedOffer) => {

package/example/src/chevre/searchOrders.ts

@@ -10,28 +10,45 @@ async function main() {
 
     const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
 
-    const orders = await orderRepo.search({
-        limit: 10,
-        project: { id: { $eq: project.id } },
-        acceptedOffers: {
-            // $size: 1
-            //     itemOffered: {
-            //         issuedThrough: { typeOf: { $eq: chevre.factory.product.ProductType.MembershipService } }
+    const order = await orderRepo.findByOrderNumber({
+        orderNumber: 'CIN4-3943271-4221863',
+        project: { id: project.id },
+        inclusion: [
+            // 'project', 'typeOf', 'orderNumber', 'dateReturned', 'id',
+            // 'customer', 'returner', 'seller', 'price', 'priceCurrency', 'orderDate'
+        ],
+        exclusion: ['acceptedOffers']
+    });
+    console.log(order);
+
+    const orders = await orderRepo.search(
+        {
+            limit: 10,
+            project: { id: { $eq: project.id } },
+            acceptedOffers: {
+                // $size: 1
+                //     itemOffered: {
+                //         issuedThrough: { typeOf: { $eq: chevre.factory.product.ProductType.MembershipService } }
+                //     }
+            },
+            orderedItem: {
+                $size: 3
+            }
+            // paymentMethods: {
+            //     paymentMethod: { identifier: { $in: ['Cash'] } }
+            //     additionalProperty: {
+            //         $in: [
+            //             { name: 'orderId', value: '0102022031518442020' },
+            //             { name: 'orderId', value: '0102022031518423030' }
+            //         ]
             //     }
+            // }
         },
-        orderedItem: {
-            $size: 3
+        {
+            orderNumber: 1,
+            customer: 1
         }
-        // paymentMethods: {
-        //     paymentMethod: { identifier: { $in: ['Cash'] } }
-        //     additionalProperty: {
-        //         $in: [
-        //             { name: 'orderId', value: '0102022031518442020' },
-        //             { name: 'orderId', value: '0102022031518423030' }
-        //         ]
-        //     }
-        // }
-    });
+    );
     console.log('orders found', orders);
     console.log(orders.length, 'orders found');
 }

package/example/src/chevre/searchReservationsByOrder.ts

@@ -0,0 +1,30 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const { reservations } = await (await chevre.service.reserve.createService()).searchByOrder({
+        limit: 10,
+        page: 1,
+        project: { id: project.id },
+        orderNumber: 'CIN3-0760465-8981560',
+        // orderNumber: 'SSK1-3743647-5975553',
+        // orderNumber: 'SSK9-4864565-8689164',
+        typeOf: chevre.factory.reservationType.EventReservation
+    })({
+        acceptedOffer: await chevre.repository.AcceptedOffer.createInstance(mongoose.connection),
+        order: await chevre.repository.Order.createInstance(mongoose.connection),
+        reservation: await chevre.repository.Reservation.createInstance(mongoose.connection)
+    });
+    console.log(reservations);
+    console.log(reservations.length, 'reservations found');
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchTransactions.ts

@@ -0,0 +1,41 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
+
+    const transactions = await transactionRepo.search<chevre.factory.transactionType.PlaceOrder>({
+        limit: 1,
+        page: 1,
+        project: { id: { $eq: project.id } },
+        typeOf: chevre.factory.transactionType.PlaceOrder,
+        statuses: [chevre.factory.transactionStatusType.Confirmed],
+        result: {
+            order: {
+                confirmationNumber: { $eq: '14438' },
+                orderNumbers: ['CIN3-0760465-8981560']
+            }
+        },
+        inclusion: ['id'],
+        exclusion: []
+    });
+    console.log('transactions found', transactions);
+    console.log(transactions.length, 'transactions found');
+
+    const transaction = await transactionRepo.findById({
+        typeOf: chevre.factory.transactionType.PlaceOrder,
+        id: '6570f9d7834f9638ceec86ad',
+        inclusion: ['_id', 'typeOf', 'status']
+    });
+    console.log('transaction found', transaction);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/transaction/processReturnOrder.ts

@@ -23,6 +23,7 @@ async function main() {
             id: 'xxx'
         }
     })({
+        acceptedOffer: await chevre.repository.AcceptedOffer.createInstance(mongoose.connection),
         event: await chevre.repository.Event.createInstance(mongoose.connection),
         merchantReturnPolicy: await chevre.repository.MerchantReturnPolicy.createInstance(mongoose.connection),
         offer: await chevre.repository.Offer.createInstance(mongoose.connection),

package/example/src/chevre/upsertMoviesByIdentifier.ts

@@ -14,9 +14,9 @@ async function main() {
     const result = await creativeWorkRepo.upsertMoviesByIdentifier(
         [
             {
-                attributes: {
+                $set: {
                     id: '',
-                    identifier: '00001',
+                    identifier: '20231215',
                     typeOf: chevre.factory.creativeWorkType.Movie,
                     duration: 'PT2H',
                     name: { ja: '名探偵コナン ゼロの執行人', en: 'Detective Conan Zero Enforcer' },
@@ -34,7 +34,7 @@ async function main() {
                             value: 'https://iwiz-movies.c.yimg.jp/c/movies/pict/p/p/90/cb/174755_02.jpg'
                         }
                     ],
-                    headline: 'サブタイトルサブタイトルサブタイトル',
+                    // headline: 'サブタイトルサブタイトル',
                     datePublished: moment('2018-11-04T15:00:00.000Z')
                         .toDate(),
                     distributor: {
@@ -44,7 +44,8 @@ async function main() {
                             distributorType: '001'
                         }
                     }
-                }
+                },
+                $unset: { headline: 1 }
             }
         ],
         { replace: true }

package/example/src/chevre/upsertOfferCatalogsByIdentifier.ts

@@ -0,0 +1,46 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const PROJECT_ID = String(process.env.PROJECT_ID);
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
+
+    const result = await offerCatalogRepo.upsertManyByIdentifier(
+        [
+            {
+                $set: {
+                    project: { typeOf: chevre.factory.organizationType.Project, id: PROJECT_ID },
+                    typeOf: 'OfferCatalog',
+                    id: '',
+                    identifier: '2023121501',
+                    itemListElement: [
+                        { id: '1001', typeOf: chevre.factory.offerType.Offer }
+                    ],
+                    itemOffered: { typeOf: chevre.factory.product.ProductType.EventService },
+                    name: {
+                        en: '2023121501',
+                        ja: '2023121501'
+                    },
+                    description: {
+                        en: '2023121501',
+                        ja: '2023121501'
+                    },
+                    additionalProperty: []
+                },
+                $unset: {}
+            }
+        ]
+        // { replace: true }
+    );
+    console.log('result:', result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/upsertOffersByIdentifier.ts

@@ -0,0 +1,94 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const PROJECT_ID = String(process.env.PROJECT_ID);
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const offerRepo = await chevre.repository.Offer.createInstance(mongoose.connection);
+
+    const result = await offerRepo.upsertByIdentifier(
+        [
+            {
+                additionalProperty: [],
+                addOn: [],
+                alternateName: { en: '', ja: '20231213' },
+                availability: chevre.factory.itemAvailability.InStock,
+                availableAtOrFrom: [],
+                itemOffered: {
+                    typeOf: chevre.factory.product.ProductType.EventService,
+                    serviceOutput: {}
+                },
+                name: { ja: '20231213', en: '20231213' },
+                priceCurrency: chevre.factory.priceCurrency.JPY,
+                priceSpecification: {
+                    name: { en: '20231213', ja: '20231213' },
+                    price: 20231213,
+                    priceCurrency: chevre.factory.priceCurrency.JPY,
+                    referenceQuantity: {
+                        typeOf: 'QuantitativeValue',
+                        value: 1,
+                        unitCode: chevre.factory.unitCode.C62
+                    },
+                    typeOf: chevre.factory.priceSpecificationType.UnitPriceSpecification,
+                    valueAddedTaxIncluded: true,
+                    accounting: {
+                        typeOf: 'Accounting',
+                        accountsReceivable: 20231213
+                    }
+                },
+                settings: { ignoreCategoryCodeChargeSpec: false },
+                description: { en: '', ja: '' },
+                hasMerchantReturnPolicy: [],
+                identifier: '20231213',
+                project: { typeOf: chevre.factory.organizationType.Project, id: PROJECT_ID },
+                typeOf: chevre.factory.offerType.Offer
+            },
+            {
+                additionalProperty: [],
+                addOn: [],
+                alternateName: { en: '', ja: '2023121302' },
+                availability: chevre.factory.itemAvailability.InStock,
+                availableAtOrFrom: [],
+                itemOffered: {
+                    typeOf: chevre.factory.product.ProductType.EventService,
+                    serviceOutput: {}
+                },
+                name: { ja: '2023121302', en: '2023121302' },
+                priceCurrency: chevre.factory.priceCurrency.JPY,
+                priceSpecification: {
+                    name: { en: '2023121302', ja: '2023121302' },
+                    price: 20231213,
+                    priceCurrency: chevre.factory.priceCurrency.JPY,
+                    referenceQuantity: {
+                        typeOf: 'QuantitativeValue',
+                        value: 1,
+                        unitCode: chevre.factory.unitCode.C62
+                    },
+                    typeOf: chevre.factory.priceSpecificationType.UnitPriceSpecification,
+                    valueAddedTaxIncluded: true,
+                    accounting: {
+                        typeOf: 'Accounting',
+                        accountsReceivable: 20231213
+                    }
+                },
+                settings: { ignoreCategoryCodeChargeSpec: false },
+                description: { en: '', ja: '' },
+                hasMerchantReturnPolicy: [],
+                identifier: '2023121302',
+                project: { typeOf: chevre.factory.organizationType.Project, id: PROJECT_ID },
+                typeOf: chevre.factory.offerType.Offer
+            }
+        ]
+        // { replace: true }
+    );
+    console.log('result:', result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/upsertScreeningEventSeriesByVersion.ts

@@ -0,0 +1,104 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const PROJECT_ID = String(process.env.PROJECT_ID);
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+
+    const result = await eventRepo.upsertScreeningEventSeriesByVersion(
+        [
+            {
+                $set: {
+                    eventStatus: chevre.factory.eventStatusType.EventScheduled,
+                    videoFormat: [],
+                    soundFormat: [],
+                    kanaName: '',
+                    startDate: moment('2023-12-08T15:00:00Z')
+                        .toDate(),
+                    endDate: moment('2123-12-08T15:00:00Z')
+                        .toDate(),
+                    typeOf: chevre.factory.eventType.ScreeningEventSeries,
+                    duration: 'PT2H',
+                    name: { ja: '名探偵コナン ゼロの執行人', en: 'Detective Conan Zero Enforcer' },
+                    offers: {
+                        typeOf: chevre.factory.offerType.Offer
+                    },
+                    project: { typeOf: chevre.factory.organizationType.Project, id: PROJECT_ID },
+                    additionalProperty: [
+                    ],
+                    location: {
+                        branchCode: '118',
+                        id: '5bfb841d5a78d7948369979a',
+                        kanaName: 'シネモーションアカサカ',
+                        name: { ja: 'シネモーション赤坂 ', en: 'CineMotion Akasaka' },
+                        typeOf: chevre.factory.placeType.MovieTheater
+                    },
+                    workPerformed: {
+                        typeOf: chevre.factory.creativeWorkType.Movie,
+                        id: '5bfb841d5a78d79483699801',
+                        identifier: '071953',
+                        name: {
+                            ja: '男はつらいよ 純情篇'
+                        },
+                        duration: 'PT1H29M',
+                        version: '2'
+                    },
+                    organizer: { id: '59d20831e53ebc2b4e774466' },
+                    headline: { ja: 'xxx', en: '' }
+                },
+                $unset: {}
+            },
+            {
+                $set: {
+                    eventStatus: chevre.factory.eventStatusType.EventScheduled,
+                    videoFormat: [],
+                    soundFormat: [],
+                    kanaName: '',
+                    startDate: moment('2023-12-08T15:00:00Z')
+                        .toDate(),
+                    endDate: moment('2123-12-08T15:00:00Z')
+                        .toDate(),
+                    typeOf: chevre.factory.eventType.ScreeningEventSeries,
+                    duration: 'PT2H',
+                    name: { ja: '名探偵コナン ゼロの執行人', en: 'Detective Conan Zero Enforcer' },
+                    offers: {
+                        typeOf: chevre.factory.offerType.Offer
+                    },
+                    project: { typeOf: chevre.factory.organizationType.Project, id: PROJECT_ID },
+                    additionalProperty: [
+                    ],
+                    location: {
+                        branchCode: '118',
+                        id: '5bfb841d5a78d7948369979a',
+                        kanaName: 'シネモーションアカサカ',
+                        name: { ja: 'シネモーション赤坂 ', en: 'CineMotion Akasaka' },
+                        typeOf: chevre.factory.placeType.MovieTheater
+                    },
+                    workPerformed: {
+                        typeOf: chevre.factory.creativeWorkType.Movie,
+                        id: '5bfb841d5a78d79483699801',
+                        identifier: '071953',
+                        name: {
+                            ja: '男はつらいよ 純情篇'
+                        },
+                        duration: 'PT1H29M',
+                        version: '6'
+                    },
+                    organizer: { id: '59d20831e53ebc2b4e774466' }
+                }
+            }
+        ]
+    );
+    console.log('result:', result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/lib/chevre/credentials.d.ts

@@ -35,9 +35,6 @@ export declare const credentials: {
     sendGrid: {
         apiKey: string | undefined;
     };
-    hub: {
-        clientId: string;
-    };
     jwt: {
         secret: string;
         issuer: string;