@cinerino/sdk 10.21.0-alpha.8 → 10.21.0

package/example/src/chevre/searchProjects.ts

@@ -37,7 +37,23 @@ async function main() {
             }
         },
         // tslint:disable-next-line:no-magic-numbers
-        40
+        1
+    );
+    setInterval(
+        async () => {
+            i += 1;
+            try {
+                const searchProjectsResult = await meService.searchProjects({
+                    limit: 10,
+                    page: 1
+                });
+                console.log(searchProjectsResult.data.length, 'projects returned', i);
+            } catch (error) {
+                console.error(error, i);
+            }
+        },
+        // tslint:disable-next-line:no-magic-numbers
+        1
     );
 }
 

package/example/src/cloud/transaction/processPlaceOrderByCreditCard3DS.ts

@@ -48,7 +48,8 @@ async function main() {
     // 新しい決済サービス
     const paymentService = await (await client.loadCloudPay({
         endpoint: <string>process.env.API_PAY_ENDPOINT,
-        auth: await auth()
+        auth: await auth(),
+        disableAutoRetry: true
     })).createPaymentInstance({
         project,
         seller: { id: '' }
@@ -128,6 +129,25 @@ async function main() {
         })({ paymentService });
         console.log('paymentUrl published.', paymentMethodId, paymentUrl);
 
+        try {
+            const publishPaymentUrlAsyncForciblySecondResult = await publishPaymentUrlAsyncForcibly({
+                object: {
+                    amount,
+                    paymentMethod: paymentMethodType,
+                    method: '1',
+                    creditCard: {
+                        ...creditCard,
+                        retUrl: String(process.env.SECURE_TRAN_RET_URL) // callbackを指定すると3DSとして処理される
+                    },
+                    issuedThrough: { id: paymentServiceId }
+                },
+                purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
+            })({ paymentService });
+            console.log('paymentUrl published.', publishPaymentUrlAsyncForciblySecondResult);
+        } catch (error) {
+            console.error('publishPaymentUrlAsyncForciblySecond:', error);
+        }
+
         // wait callback...
         await new Promise<void>((resolve, reject) => {
             const rl = readline.createInterface({
@@ -135,8 +155,14 @@ async function main() {
                 output: process.stdout
             });
 
-            rl.question('callback received?:\n', async () => {
+            rl.question('callback received? y or n:\n', async (answer) => {
                 try {
+                    if (answer !== 'y') {
+                        reject(new Error('answer is no'));
+
+                        return;
+                    }
+
                     console.log('authorizing credit card payment...');
                     const creditCardPaymentAuth = await authorizeCreditCardAsyncForcibly({
                         object: {
@@ -154,6 +180,7 @@ async function main() {
 
                     // tslint:disable-next-line:no-magic-numbers
                     await wait(3000);
+                    // throw new Error('unexpected error');
 
                     console.log('setting customer profile...');
                     await placeOrderService.setProfile({
@@ -409,7 +436,27 @@ function authorizeCreditCardAsyncForcibly(params: {
         paymentService: client.cloudPay.service.Payment;
     }): Promise<{ id: string }> => {
         // 決済承認タスク作成
-        const authorizeTask = await repos.paymentService.authorizeCreditCardAsync(params);
+        const authorizeTask = await new Promise<{ id: string }>((resolve, reject) => {
+            repos.paymentService.authorizeCreditCardAsync(params)
+                .then(async (task) => {
+                    console.log('waiting resolve authorizeCreditCardAsync...');
+                    await wait(5000);
+
+                    resolve(task);
+                })
+                .catch(reject);
+            // 再度承認してみる
+            // repos.paymentService.authorizeCreditCardAsync(params)
+            //     .then(async (task) => {
+            //         console.log('authorizeCreditCardAsync:', task);
+            //     })
+            //     .catch((authorizeCreditCardAsyncError) => {
+            //         // 同paymentMethodIdでは承認できないはず
+            //         console.error('authorizeCreditCardAsync:', authorizeCreditCardAsyncError);
+            //     });
+
+        });
+
         const giveUpPayment = moment()
             .add(USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_GIVE_UP_SECONDS, 'seconds');
         let result: { id: string } | undefined;

package/example/src/cloud/transaction/processPlaceOrderUsingMemberProgramTier.ts

@@ -0,0 +1,517 @@
+// tslint:disable:no-console no-implicit-dependencies no-magic-numbers
+import * as moment from 'moment';
+import * as readline from 'readline';
+import * as client from '../../../../lib/index';
+import { auth } from '../../auth/clientCredentials';
+
+const { EVENT_ID, MEMBER_PROGRAM_TIER_TOKEN } = process.env;
+const project = { id: String(process.env.PROJECT_ID) };
+const profile = {
+    email: <string>process.env.TEST_PROFILE_EMAIL,
+    givenName: 'Taro',
+    familyName: 'SDK',
+    name: 'Taro ☆ SDK',
+    telephone: '+819012345678'
+};
+const paymentMethodType = 'CreditCard3DS';
+const paymentServiceId = '664d98376fb87922bd6a4e52';
+// 取引に使用するクレジットカード
+const creditCard: client.factory.paymentMethod.paymentCard.creditCard.IUncheckedCardRaw = {
+    cardNo: '4100000000000100',
+    expire: '2812',
+    cardPass: '123',
+    holderName: 'AA AA'
+};
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const eventService = new (await client.loadService()).Event({
+        endpoint: <string>process.env.API_ENDPOINT,
+        auth: await auth(),
+        project,
+        seller: { id: '' }
+    });
+
+    const sellerService = new (await client.loadService()).Seller({
+        endpoint: <string>process.env.API_ENDPOINT,
+        auth: await auth(),
+        project
+    });
+
+    const placeOrderService = await (await client.loadCloudTxn({
+        endpoint: <string>process.env.API_TXN_ENDPOINT,
+        auth: await auth()
+    })).createPlaceOrderInstance({
+        project,
+        seller: { id: '' }
+    });
+
+    // 新しい決済サービス
+    const paymentService = await (await client.loadCloudPay({
+        endpoint: <string>process.env.API_PAY_ENDPOINT,
+        auth: await auth(),
+        disableAutoRetry: true
+    })).createPaymentInstance({
+        project,
+        seller: { id: '' }
+    });
+
+    // 販売劇場検索
+    const searchSellersResult = await sellerService.search({ branchCode: { $eq: '001' } });
+    // tslint:disable-next-line:insecure-random
+    const seller = searchSellersResult.data[Math.floor(searchSellersResult.data.length * Math.random())];
+    if (seller === undefined) {
+        throw new Error('No seller');
+    }
+    console.log('ordering from seller...', (<client.factory.multilingualString>seller.name).ja);
+
+    // イベント検索
+    const searchScreeningEventsResult = await eventService.search<client.factory.eventType.ScreeningEvent>({
+        id: { $eq: EVENT_ID },
+        typeOf: client.factory.eventType.ScreeningEvent,
+        inSessionFrom: moment()
+            .toDate(),
+        inSessionThrough: moment()
+            .add(1, 'week')
+            .toDate()
+    });
+    console.log(searchScreeningEventsResult.data.length, 'events found');
+
+    const availableEvents = searchScreeningEventsResult.data;
+    if (availableEvents.length === 0) {
+        throw new Error('No available events');
+    }
+
+    console.log('starting transaction...');
+    const transaction = await placeOrderService.start({
+        agent: {
+            identifier: [
+                { name: 'fromSamples', value: 'true' }
+            ]
+        },
+        seller: { id: String(seller.id) },
+        object: {
+            // passport: { token: passportToken }
+        }
+    });
+    console.log('transaction started', transaction.id);
+
+    try {
+        const numEvents = 1;
+        let amount = 0;
+        // tslint:disable-next-line:max-line-length
+        const authorizeSeatReservationResults: { price: number }[] = [];
+
+        // tslint:disable-next-line:no-increment-decrement
+        for (let i = 0; i < numEvents; i++) {
+            // イベント決定
+            // tslint:disable-next-line:insecure-random
+            const screeningEvent = availableEvents[Math.floor(availableEvents.length * Math.random())];
+            const authorizeSeatReservationResult = await authorizeSeatReservationByEvent({
+                event: screeningEvent,
+                transaction: transaction
+            });
+            amount += Number(authorizeSeatReservationResult.price);
+            authorizeSeatReservationResults.push(authorizeSeatReservationResult);
+        }
+
+        // 決済URL発行
+        const { paymentMethodId, paymentUrl } = await publishPaymentUrlAsyncForcibly({
+            object: {
+                amount,
+                paymentMethod: paymentMethodType,
+                method: '1',
+                creditCard: {
+                    ...creditCard,
+                    retUrl: String(process.env.SECURE_TRAN_RET_URL) // callbackを指定すると3DSとして処理される
+                },
+                issuedThrough: { id: paymentServiceId }
+            },
+            purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
+        })({ paymentService });
+        console.log('paymentUrl published.', paymentMethodId, paymentUrl);
+
+        try {
+            const publishPaymentUrlAsyncForciblySecondResult = await publishPaymentUrlAsyncForcibly({
+                object: {
+                    amount,
+                    paymentMethod: paymentMethodType,
+                    method: '1',
+                    creditCard: {
+                        ...creditCard,
+                        retUrl: String(process.env.SECURE_TRAN_RET_URL) // callbackを指定すると3DSとして処理される
+                    },
+                    issuedThrough: { id: paymentServiceId }
+                },
+                purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
+            })({ paymentService });
+            console.log('paymentUrl published.', publishPaymentUrlAsyncForciblySecondResult);
+        } catch (error) {
+            console.error('publishPaymentUrlAsyncForciblySecond:', error);
+        }
+
+        // wait callback...
+        await new Promise<void>((resolve, reject) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+
+            rl.question('callback received? y or n:\n', async (answer) => {
+                try {
+                    if (answer !== 'y') {
+                        reject(new Error('answer is no'));
+
+                        return;
+                    }
+
+                    console.log('authorizing credit card payment...');
+                    const creditCardPaymentAuth = await authorizeCreditCardAsyncForcibly({
+                        object: {
+                            amount,
+                            // amount: 1, // 間違えてみる
+                            paymentMethod: paymentMethodType,
+                            paymentMethodId, // URL発行時のpaymentMethodIdを指定
+                            method: '1',
+                            creditCard,
+                            issuedThrough: { id: paymentServiceId }
+                        },
+                        purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
+                    })({ paymentService });
+                    console.log('credit card payment authorized', creditCardPaymentAuth.id);
+
+                    // tslint:disable-next-line:no-magic-numbers
+                    await wait(3000);
+                    // throw new Error('unexpected error');
+
+                    console.log('setting customer profile...');
+                    await placeOrderService.setProfile({
+                        id: transaction.id,
+                        agent: profile
+                    });
+                    console.log('customer profile set');
+
+                    await wait(3000);
+
+                    // console.log('voiding credit card auth...');
+                    // await paymentService.voidTransaction({
+                    //     id: creditCardPaymentAuth.id,
+                    //     object: { typeOf: client.factory.service.paymentService.PaymentServiceType.CreditCard },
+                    //     purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
+                    // });
+                    // console.log('credit card auth voided');
+                    // await wait(3000);
+                    // return;
+
+                    console.log('confirming transaction...');
+
+                    let confirmResult = await placeOrderService.confirmWithMiminalResponse({ id: transaction.id });
+                    console.log('transaction confirmed', confirmResult);
+
+                    // 何度確定をコールしても冪等
+                    console.log('reconfirming transaction...');
+                    confirmResult = await placeOrderService.confirmWithMiminalResponse({ id: transaction.id });
+                    console.log('transaction reconfirmed', confirmResult);
+                    resolve();
+                } catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    } catch (error) {
+        console.error(error);
+
+        await wait(3000);
+
+        console.log('canceling transaction...');
+        await placeOrderService.cancel({ id: transaction.id });
+        console.log('transaction canceled.');
+    }
+}
+
+type IAuthorizeReservationAction = Pick<client.factory.action.authorize.offer.eventService.IAction, 'id'> & {
+    result?: {
+        price?: number;
+    };
+};
+
+// tslint:disable-next-line:max-func-body-length
+async function authorizeSeatReservationByEvent(params: {
+    event: Omit<client.factory.event.screeningEvent.IEvent, 'offers'>;
+    transaction: Pick<client.factory.transaction.placeOrder.ITransaction, 'id'>;
+}): Promise<{
+    price: number;
+}> {
+    const eventService = new (await client.loadService()).Event({
+        endpoint: <string>process.env.API_ENDPOINT,
+        auth: await auth(),
+        project,
+        seller: { id: '' }
+    });
+
+    const offerService = await (await client.loadCloudTxn({
+        endpoint: <string>process.env.API_TXN_ENDPOINT,
+        auth: await auth()
+    })).createOfferInstance({
+        project,
+        seller: { id: '' }
+    });
+
+    const screeningEvent = params.event;
+    const transaction = params.transaction;
+
+    // 券種検索
+    let ticketOffers = await eventService.searchTicketOffers({
+        event: { id: screeningEvent.id }
+    });
+    console.log('チケットオファーは以下の通りです');
+    console.log(ticketOffers.map((o) => {
+        const unitPriceSpecification = o.priceSpecification.priceComponent
+            .filter((s) => s.typeOf === client.factory.priceSpecificationType.UnitPriceSpecification)
+            .map((s) => `単価:${s.price}/${(<client.factory.priceSpecification.IPriceSpecification<client.factory.priceSpecificationType.UnitPriceSpecification>>s).referenceQuantity.value}`)
+            .join(' ');
+        const categoryCodeCharge = o.priceSpecification.priceComponent
+            .filter((s) => s.typeOf === client.factory.priceSpecificationType.CategoryCodeChargeSpecification)
+            .map((s) => `+${(<client.factory.priceSpecification.IPriceSpecification<client.factory.priceSpecificationType.CategoryCodeChargeSpecification>>s).appliesToCategoryCode[0].codeValue}チャージ:${s.price} ${s.priceCurrency}`)
+            .join(' ');
+
+        return `${o.id} ${(<client.factory.multilingualString>o.name).ja} ${unitPriceSpecification} ${categoryCodeCharge}`;
+    })
+        .join('\n'));
+
+    // 空席検索
+    const searchSeatOffersResult = await eventService.searchSeats({
+        event: { id: screeningEvent.id },
+        limit: 100,
+        page: 1
+    });
+    const seatOffers = searchSeatOffersResult.data;
+    // console.log(seatOffers.length, 'seatOffers found');
+    // const seatOffers = offers[0].containsPlace;
+    console.log(seatOffers.length, 'seatOffers found');
+    const availableSeatOffers
+        = seatOffers.filter((o) => o.offers?.shift()?.availability === client.factory.itemAvailability.InStock);
+    console.log(availableSeatOffers.length, 'availableSeatOffers found');
+    if (availableSeatOffers.length <= 0) {
+        throw new Error('No available seats');
+    }
+
+    // ムビチケ以外のメンバーシップオファーを選択
+    ticketOffers = ticketOffers
+        .filter((offer) => {
+            const movieTicketTypeChargeSpecification = offer.priceSpecification.priceComponent.find(
+                (component) => component.typeOf === client.factory.priceSpecificationType.MovieTicketTypeChargeSpecification
+            );
+
+            return movieTicketTypeChargeSpecification === undefined;
+        });
+
+    const selectedTicketOffer = ticketOffers.shift();
+    if (selectedTicketOffer === undefined) {
+        throw new Error('selectedTicketOffer undefined');
+    }
+    console.log('ticket offer selected', selectedTicketOffer.id, selectedTicketOffer.identifier, selectedTicketOffer.name.ja);
+
+    // 座席をランダムに選択
+    const selectedScreeningRoomSection = String(availableSeatOffers[0].containedInPlace?.branchCode);
+    console.log('screening room section selected', selectedScreeningRoomSection);
+    console.log(selectedScreeningRoomSection);
+    const selectedSeatOffers = availableSeatOffers.slice(0, 1);
+    console.log(selectedSeatOffers.length, 'seats selected');
+
+    await wait(3000);
+    console.log('authorizing seat reservation...');
+    const seatReservationAuth = <IAuthorizeReservationAction>await offerService.authorizeEventService({
+        object: {
+            reservationFor: {
+                id: screeningEvent.id,
+                offers: { validForMemberTier: MEMBER_PROGRAM_TIER_TOKEN }
+            },
+            acceptedOffer: selectedSeatOffers.map((o) => {
+                return {
+                    typeOf: selectedTicketOffer.typeOf,
+                    id: String(selectedTicketOffer.id),
+                    itemOffered: {
+                        serviceOutput: {
+                            typeOf: client.factory.reservationType.EventReservation,
+                            reservedTicket: {
+                                typeOf: 'Ticket',
+                                ticketedSeat: {
+                                    typeOf: client.factory.placeType.Seat,
+                                    seatNumber: o.branchCode,
+                                    seatSection: selectedScreeningRoomSection,
+                                    seatRow: ''
+                                }
+                            }
+                        }
+                    },
+                    additionalProperty: [{ name: 'sampleName', value: 'sampleValue' }]
+                };
+            })
+        },
+        purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
+    });
+    console.log('seat reservation authorized', seatReservationAuth.id);
+
+    const price = seatReservationAuth.result?.price;
+    // 金額計算
+    if (typeof price !== 'number') {
+        throw new Error('result.price undefined');
+    }
+    console.log('price:', price);
+
+    return { price };
+}
+
+async function wait(waitInMilliseconds: number) {
+    return new Promise((resolve) => setTimeout(resolve, waitInMilliseconds));
+}
+
+const USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_GIVE_UP_SECONDS = 10;
+const USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_CHECK_INTERVAL_MS = 1000;
+function publishPaymentUrlAsyncForcibly(params: {
+    object: Pick<client.factory.action.authorize.paymentMethod.any.IObjectWithoutDetail, 'amount' | 'creditCard' | 'issuedThrough' | 'paymentMethod' | 'method'>;
+    purpose: {
+        typeOf: client.factory.transactionType.PlaceOrder;
+        id: string;
+    };
+}) {
+    return async (repos: {
+        paymentService: client.cloudPay.service.Payment;
+    }): Promise<client.factory.action.accept.pay.IResult> => {
+        const acceptTask = await repos.paymentService.publishCreditCardPaymentUrlAsync(params);
+        const giveUpPayment = moment()
+            .add(USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_GIVE_UP_SECONDS, 'seconds');
+        let result: client.factory.action.accept.pay.IResult | undefined;
+        let error: { name?: string; message?: string } | undefined;
+
+        // n秒おきに状態確認
+        while (result === undefined && error === undefined) {
+            await wait(USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_CHECK_INTERVAL_MS); // n秒待機
+
+            // タスク作成から一定時間経過すればあきらめる
+            if (moment()
+                .isAfter(giveUpPayment)) {
+                error = new client.factory.errors.GatewayTimeout('action given up');
+                break;
+            }
+
+            const acceptAction = await repos.paymentService.findAcceptPayAction({
+                sameAs: { id: acceptTask.id },
+                purpose: params.purpose
+            });
+
+            // CompletedActionStatusであればタスク完了とみなす
+            if (acceptAction.actionStatus === client.factory.actionStatusType.CompletedActionStatus
+                && acceptAction.result !== undefined) {
+                result = acceptAction.result;
+                break;
+            } else {
+                // 待機続行
+            }
+
+            // エラーが存在すれば、これ以上待機する価値はなし
+            if (acceptAction.error !== undefined) {
+                error = acceptAction.error;
+                break;
+            }
+        }
+
+        if (typeof result?.paymentMethodId === 'string') {
+            return result;
+        }
+
+        throw error;
+    };
+}
+
+function authorizeCreditCardAsyncForcibly(params: {
+    object: Pick<
+        client.factory.action.authorize.paymentMethod.any.IObjectWithoutDetail,
+        'amount' | 'issuedThrough' | 'paymentMethod' | 'creditCard' | 'method' | 'paymentMethodId' | 'name' | 'additionalProperty'
+    >;
+    purpose: {
+        typeOf: client.factory.transactionType.PlaceOrder;
+        id: string;
+    };
+}) {
+    return async (repos: {
+        paymentService: client.cloudPay.service.Payment;
+    }): Promise<{ id: string }> => {
+        // 決済承認タスク作成
+        const authorizeTask = await new Promise<{ id: string }>((resolve, reject) => {
+            repos.paymentService.authorizeCreditCardAsync(params)
+                .then(async (task) => {
+                    console.log('waiting resolve authorizeCreditCardAsync...');
+                    await wait(5000);
+
+                    resolve(task);
+                })
+                .catch(reject);
+            // 再度承認してみる
+            // repos.paymentService.authorizeCreditCardAsync(params)
+            //     .then(async (task) => {
+            //         console.log('authorizeCreditCardAsync:', task);
+            //     })
+            //     .catch((authorizeCreditCardAsyncError) => {
+            //         // 同paymentMethodIdでは承認できないはず
+            //         console.error('authorizeCreditCardAsync:', authorizeCreditCardAsyncError);
+            //     });
+
+        });
+
+        const giveUpPayment = moment()
+            .add(USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_GIVE_UP_SECONDS, 'seconds');
+        let result: { id: string } | undefined;
+        let error: { name?: string; message?: string } | undefined;
+
+        // n秒おきに状態確認
+        while (result === undefined && error === undefined) {
+            await wait(USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_CHECK_INTERVAL_MS); // n秒待機
+
+            // タスク作成から一定時間経過すればあきらめる
+            if (moment()
+                .isAfter(giveUpPayment)) {
+                error = new client.factory.errors.GatewayTimeout('action given up');
+                break;
+            }
+
+            const authorizeAction = await repos.paymentService.findAuthorizeAction({
+                sameAs: { id: authorizeTask.id },
+                object: {
+                    typeOf: client.factory.service.paymentService.PaymentServiceType.CreditCard
+                },
+                purpose: params.purpose
+            });
+
+            // アクションIDが存在し、CompletedActionStatusであればタスク完了とみなす
+            if (typeof authorizeAction.id === 'string') {
+                if (authorizeAction.actionStatus === client.factory.actionStatusType.CompletedActionStatus) {
+                    // ステータス完了であれば決済承認アクションIDを保管
+                    result = { id: authorizeAction.id };
+                    break;
+                } else {
+                    // 待機続行
+                }
+            }
+
+            // エラーが存在すれば、これ以上待機する価値はなし
+            if (authorizeAction.error !== undefined) {
+                error = authorizeAction.error;
+                break;
+            }
+        }
+
+        if (typeof result?.id === 'string') {
+            return result;
+        }
+
+        throw error;
+    };
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/findEventById.ts

@@ -1,23 +1,32 @@
-// tslint:disable:no-implicit-dependencies no-console
+// tslint:disable:no-implicit-dependencies no-console no-null-keyword
+// import * as fs from 'fs';
 import * as client from '../../lib/index';
+// import * as auth from './auth/authAsAdmin';
 import { auth } from './auth/clientCredentials';
 
 const PROJECT_ID = String(process.env.PROJECT_ID);
 
 async function main() {
+    // const authClient = await auth.login();
+    // await authClient.refreshAccessToken();
+    // const loginTicket = authClient.verifyIdToken({});
+    // console.log('username is', loginTicket.getUsername());
+
     const eventService = new (await client.loadService()).Event({
         endpoint: <string>process.env.API_ENDPOINT,
         auth: await auth(),
+        // auth: authClient,
         project: { id: PROJECT_ID },
-        seller: { id: '' }
+        seller: { id: '59d20831e53ebc2b4e774466' }
     });
 
     const event = await eventService.findById({
         id: 'bm2bfj55o',
         typeOf: client.factory.eventType.ScreeningEvent
     });
-    // tslint:disable-next-line:no-null-keyword
     console.dir(event, { depth: null });
+    // tslint:disable-next-line:non-literal-fs-path
+    // fs.writeFileSync(`${__dirname}/event2.json`, JSON.stringify(event, null, '    '));
 }
 
 main()

package/lib/abstract/chevre/event.d.ts

@@ -77,6 +77,9 @@ export declare class EventService extends Service {
         };
         onlyValid?: boolean;
         includePotentialSpec?: boolean;
+        /**
+         * サブカタログに含まれるオファーを検索する場合、強制的にサブカタログの適用決済カード条件に変更されます
+         */
         priceSpecification: Pick<factory.unitPriceOffer.IPriceSpecificationSearchConditions, 'appliesToMovieTicket'>;
         includedInDataCatalog: {
             /**