@cinerino/sdk 12.3.0-alpha.1 → 12.3.0-alpha.11

package/example/src/cloud/admin/adminCreateEventIfNotExistByIdentifierBySoftware.ts

@@ -0,0 +1,102 @@
+// tslint:disable:no-console
+// tslint:disable-next-line:no-implicit-dependencies
+import * as moment from 'moment-timezone';
+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);
+const SELLER_ID = '5a392dfdfca1c8737fb6da42';
+const EVENT_SERVICE_ID = '630b139e4dd0621c0496a30c';
+const AVAILABLE_AT_OR_FROM_ID = '51qbjcfr72h62m06vtv5kkhgje';
+const ADDITIONAL_PROPERTY_NAME = 'oldEventId';
+const SUPER_EVENT_ID = '7kaf1djmz';
+const LOCATION_BRANCH_CODE = '01';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    // const authClient = await auth.login();
+    // await authClient.refreshAccessToken();
+    // const loginTicket = authClient.verifyIdToken({});
+    // console.log('username is', loginTicket.getUsername());
+
+    const eventService = await (await client.loadCloudAdmin({
+        endpoint: <string>process.env.API_ADMIN_ENDPOINT,
+        auth: await auth()
+    })).createEventInstance({
+        project: { id: PROJECT_ID },
+        seller: { id: SELLER_ID }
+    });
+
+    const today = moment()
+        .tz('Asia/Tokyo')
+        .format('YYYY-MM-DD');
+    const identifier = '250909001001010900';
+    await eventService.createIfNotExistByIdentifier(
+        [
+            {
+                identifier,
+                doorTime: moment(`${today}T13:00:00Z`)
+                    .toDate(),
+                startDate: moment(`${today}T13:00:00Z`)
+                    .toDate(),
+                endDate: moment(`${today}T14:00:00Z`)
+                    .toDate(),
+                eventStatus: client.factory.eventStatusType.EventScheduled,
+                additionalProperty: [
+                    { name: ADDITIONAL_PROPERTY_NAME, value: identifier }
+                ],
+                offers: {
+                    unacceptedPaymentMethod: [],
+                    eligibleQuantity: {
+                        maxValue: 6
+                    },
+                    itemOffered: {
+                        id: EVENT_SERVICE_ID
+                    },
+                    seller: {
+                        makesOffer: [
+                            {
+                                typeOf: client.factory.offerType.Offer,
+                                availableAtOrFrom: { id: AVAILABLE_AT_OR_FROM_ID }, // <-販売アプリケーションIDを指定する
+                                availabilityStarts: moment(`${today}T00:00:00+09:00`)
+                                    .toDate(),
+                                availabilityEnds: moment(`${today}T14:00:00Z`)
+                                    .toDate(),
+                                validFrom: moment(`${today}T00:00:00+09:00`)
+                                    .toDate(),
+                                validThrough: moment(`${today}T14:00:00Z`)
+                                    .toDate()
+                            }
+                        ]
+                        // makesOfferDefaultを指定するとmakesOfferよりも優先される
+                        // makesOfferDefault: {
+                        //     typeOf: client.factory.offerType.Offer,
+                        //     availabilityStarts: moment('2024-05-11T00:00:00.000Z')
+                        //         .toDate(),
+                        //     availabilityEnds: moment('2024-05-12T00:00:00.000Z')
+                        //         .toDate(),
+                        //     validFrom: moment('2024-05-11T00:00:00.000Z')
+                        //         .toDate(),
+                        //     validThrough: moment('2024-05-12T00:00:00.000Z')
+                        //         .toDate()
+                        // }
+                    }
+                }
+            }
+        ],
+        {
+            locationBranchCode: LOCATION_BRANCH_CODE,
+            superEventId: SUPER_EVENT_ID,
+            hasTicketedSeat: true,
+            typeOf: client.factory.eventType.ScreeningEvent
+        }
+    );
+    console.log('created.');
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/cloud/admin/adminUpsertManyEventsByAdditionalProperty.ts

@@ -1,6 +1,6 @@
 // tslint:disable:no-console
 // tslint:disable-next-line:no-implicit-dependencies
-import * as moment from 'moment';
+import * as moment from 'moment-timezone';
 import * as client from '../../../../lib/index';
 import * as auth from '../../auth/authAsAdmin';
 
@@ -24,24 +24,18 @@ async function main() {
         seller: { id: SELLER_ID }
     });
 
+    const today = moment()
+        .tz('Asia/Tokyo')
+        .format('YYYY-MM-DD');
     await eventService.upsertManyByAdditionalProperty({
         filter: { name: ADDITIONAL_PROPERTY_NAME },
-        options: {
-            superEventId: '7k9ayl8hc',
-            locationBranchCode: '10'
-        },
         attributes: [
             {
-                typeOf: client.factory.eventType.ScreeningEvent,
-                project: {
-                    typeOf: client.factory.organizationType.Project,
-                    id: PROJECT_ID
-                },
-                doorTime: moment('2025-09-01T10:00:00Z')
+                doorTime: moment(`${today}T13:00:00Z`)
                     .toDate(),
-                startDate: moment('2025-09-01T10:00:00Z')
+                startDate: moment(`${today}T13:00:00Z`)
                     .toDate(),
-                endDate: moment('2025-09-01T11:00:00Z')
+                endDate: moment(`${today}T14:00:00Z`)
                     .toDate(),
                 eventStatus: client.factory.eventStatusType.EventScheduled,
                 additionalProperty: [
@@ -52,9 +46,9 @@ async function main() {
                     }
                 ],
                 // maximumPhysicalAttendeeCapacity: 3,
-                // location: {
-                //     branchCode: '10'
-                // },
+                location: {
+                    branchCode: '10'
+                },
                 superEvent: {
                     id: '7k9ayl8hc'
                 },
@@ -64,20 +58,24 @@ async function main() {
                         maxValue: 6
                     },
                     itemOffered: {
-                        id: EVENT_SERVICE_ID
+                        id: EVENT_SERVICE_ID,
+                        serviceOutput: {
+                            typeOf: client.factory.reservationType.EventReservation,
+                            reservedTicket: { typeOf: 'Ticket', ticketedSeat: { typeOf: client.factory.placeType.Seat } }
+                        }
                     },
                     seller: {
                         makesOffer: [
                             {
                                 typeOf: client.factory.offerType.Offer,
                                 availableAtOrFrom: { id: AVAILABLE_AT_OR_FROM_ID }, // <-販売アプリケーションIDを指定する
-                                availabilityStarts: moment('2025-06-30T10:00:00Z')
+                                availabilityStarts: moment(`${today}T13:00:00Z`)
                                     .toDate(),
-                                availabilityEnds: moment('2025-09-30T10:00:00Z')
+                                availabilityEnds: moment(`${today}T14:00:00Z`)
                                     .toDate(),
-                                validFrom: moment('2025-06-30T10:00:00Z')
+                                validFrom: moment(`${today}T13:00:00Z`)
                                     .toDate(),
-                                validThrough: moment('2025-09-30T10:00:00Z')
+                                validThrough: moment(`${today}T14:00:00Z`)
                                     .toDate()
                             }
                         ]

package/example/src/cloud/findOrderByConfirmationNumber.ts

@@ -14,9 +14,9 @@ async function main() {
         seller: { id: '' }
     });
     const orders = await orderService.findByConfirmationNumber({
-        confirmationNumber: '96678',
+        confirmationNumber: '74441',
         customer: {
-            telephone: '+819012345678'
+            telephone: '+819011111111'
         }
     });
     // tslint:disable-next-line:no-null-keyword

package/example/src/cloud/search/findProducts.ts

@@ -19,7 +19,8 @@ async function main() {
         page: 1,
         typeOf: factory.product.ProductType.EventService
     });
-    console.log(result);
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result, { depth: null });
     console.log(result.length, 'data found');
 }
 

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

@@ -237,7 +237,7 @@ type IAuthorizeReservationAction = Pick<client.factory.action.authorize.offer.ev
 
 // tslint:disable-next-line:max-func-body-length
 async function authorizeSeatReservationByEvent(params: {
-    event: Omit<client.factory.event.screeningEvent.IEvent, 'offers'>;
+    event: { id: string };
     transaction: Pick<client.factory.transaction.placeOrder.ITransaction, 'id'>;
 }): Promise<{
     price: number;
@@ -320,12 +320,20 @@ async function authorizeSeatReservationByEvent(params: {
     console.log(selectedSeatOffers.length, 'seats selected');
 
     await wait(3000);
+    if (typeof MEMBER_PROGRAM_TIER_TOKEN !== 'string') {
+        throw new Error('process.env.MEMBER_PROGRAM_TIER_TOKEN required');
+    }
     console.log('authorizing seat reservation...');
     const seatReservationAuth = <IAuthorizeReservationAction>await offerService.authorizeEventService({
         object: {
             reservationFor: {
                 id: screeningEvent.id,
-                offers: { validForMemberTier: MEMBER_PROGRAM_TIER_TOKEN }
+                offers: {
+                    validForMemberTier: {
+                        token: MEMBER_PROGRAM_TIER_TOKEN,
+                        isTierOf: { identifier: 'DefaultMemberProgram' }
+                    }
+                }
             },
             acceptedOffer: selectedSeatOffers.map((o) => {
                 return {

package/example/src/searchEvents.ts

@@ -6,6 +6,7 @@ import { auth } from './auth/clientCredentials';
 const PROJECT_ID = String(process.env.PROJECT_ID);
 
 async function main() {
+    const now = new Date();
     const eventService = new (await client.loadService()).Event({
         endpoint: <string>process.env.API_ENDPOINT,
         auth: await auth(),
@@ -17,17 +18,18 @@ async function main() {
         page: 1,
         limit: 1,
         typeOf: client.factory.eventType.ScreeningEvent,
-        startFrom: new Date(),
-        startThrough: moment()
+        startFrom: now,
+        startThrough: moment(now)
             .add(1, 'days')
             .toDate(),
         sort: {
             startDate: client.factory.sortType.Ascending
         },
-        sellerMakesOfferAvailableAtIn: ['xx', 'xxx']
+        sellerMakesOfferAvailableAtIn: ['xx', 'xxx'],
+        identifiers: ['x', 'x']
     });
     // tslint:disable-next-line:no-null-keyword
-    // console.dir(data.at(0), { depth: null });
+    console.dir(data.at(0), { depth: null });
     // tslint:disable-next-line:no-null-keyword
     // console.dir(data.at(0)?.offers?.seller.makesOffer, { depth: null });
     console.log(data.length, 'events');

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

@@ -0,0 +1,29 @@
+import * as factory from '../factory';
+import { Service } from '../service';
+export declare type IProductOfferAsFindResult = Pick<factory.productOffer.IProductOffer, 'acceptedPaymentMethod' | 'availability' | 'identifier' | 'itemOffered' | 'validForMemberTier' | 'validFrom' | 'validThrough'> & {
+    id: string;
+};
+export interface IFindParams {
+    /**
+     * max: 20
+     */
+    limit: number;
+    page: number;
+    /**
+     * オファーコレクションコード
+     * max length: 10
+     */
+    itemOfferedIdentifiers?: string[];
+    /**
+     * オファーコード
+     * max length: 10
+     */
+    identifiers?: string[];
+    id?: string;
+}
+/**
+ * プロダクトオファーサービス
+ */
+export declare class ProductOfferService extends Service {
+    findProductOffers(params: IFindParams): Promise<IProductOfferAsFindResult[]>;
+}

package/lib/abstract/chevre/productOffer.js

@@ -0,0 +1,84 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductOfferService = void 0;
+var http_status_1 = require("http-status");
+var service_1 = require("../service");
+var BASE_URI = '/productOffers';
+/**
+ * プロダクトオファーサービス
+ */
+var ProductOfferService = /** @class */ (function (_super) {
+    __extends(ProductOfferService, _super);
+    function ProductOfferService() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ProductOfferService.prototype.findProductOffers = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetch({
+                        uri: BASE_URI,
+                        method: 'GET',
+                        qs: params,
+                        expectedStatusCodes: [http_status_1.OK]
+                    })
+                        .then(function (response) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, response.json()];
+                    }); }); })];
+            });
+        });
+    };
+    return ProductOfferService;
+}(service_1.Service));
+exports.ProductOfferService = ProductOfferService;

package/lib/abstract/chevre.d.ts

@@ -8,6 +8,7 @@ import type { PaymentProductService } from './chevre/paymentService';
 import type { PlaceService } from './chevre/place';
 import type { HasPOSService } from './chevre/place/hasPOS';
 import type { ProductService } from './chevre/product';
+import type { ProductOfferService } from './chevre/productOffer';
 import type { SellerService } from './chevre/seller';
 import type { TripService } from './chevre/trip';
 export declare namespace service {
@@ -77,6 +78,13 @@ export declare namespace service {
     namespace Product {
         let svc: typeof ProductService | undefined;
     }
+    /**
+     * プロダクトオファーサービス
+     */
+    type ProductOffer = ProductOfferService;
+    namespace ProductOffer {
+        let svc: typeof ProductOfferService | undefined;
+    }
     /**
      * 販売者サービス
      */
@@ -107,6 +115,7 @@ export declare class Chevre {
     createPlaceInstance(params: Pick<IOptions, 'project'> & Pick<IAdditionalOptions, 'seller'>): Promise<PlaceService>;
     createHasPOSInstance(params: Pick<IOptions, 'project'> & Pick<IAdditionalOptions, 'seller'>): Promise<HasPOSService>;
     createProductInstance(params: Pick<IOptions, 'project'> & Pick<IAdditionalOptions, 'seller'>): Promise<ProductService>;
+    createProductOfferInstance(params: Pick<IOptions, 'project'> & Pick<IAdditionalOptions, 'seller'>): Promise<ProductOfferService>;
     createSellerInstance(params: Pick<IOptions, 'project'>): Promise<SellerService>;
     createTripInstance(params: Pick<IOptions, 'project'> & Pick<IAdditionalOptions, 'seller'>): Promise<TripService>;
 }

package/lib/abstract/chevre.js

@@ -80,6 +80,9 @@ var service;
     var Product;
     (function (Product) {
     })(Product = service.Product || (service.Product = {}));
+    var ProductOffer;
+    (function (ProductOffer) {
+    })(ProductOffer = service.ProductOffer || (service.ProductOffer = {}));
     var Seller;
     (function (Seller) {
     })(Seller = service.Seller || (service.Seller = {}));
@@ -247,6 +250,23 @@ var Chevre = /** @class */ (function () {
             });
         });
     };
+    Chevre.prototype.createProductOfferInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.ProductOffer.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.ProductOffer;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevre/productOffer'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).ProductOfferService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.ProductOffer.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
     Chevre.prototype.createSellerInstance = function (params) {
         return __awaiter(this, void 0, void 0, function () {
             var _a;

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

@@ -3,10 +3,51 @@ import { Service } from '../service';
 declare type ISendEmailMessageOnEventUpdated = Pick<factory.action.transfer.send.message.email.IAttributes, 'purpose' | 'recipient'> & {
     object: factory.action.transfer.send.message.email.IObjectAsEmailMessage;
 };
+export declare type ICreateParamsByIdentifier = Pick<factory.event.ICreateParams<factory.eventType.ScreeningEvent>, 'additionalProperty' | 'doorTime' | 'endDate' | 'eventStatus' | 'maximumPhysicalAttendeeCapacity' | 'offers' | 'startDate'> & {
+    identifier: string;
+    offers: Pick<factory.event.screeningEvent.IOffers4create, 'eligibleQuantity' | 'seller' | 'unacceptedPaymentMethod'> & {
+        itemOffered: Pick<factory.event.screeningEvent.IItemOffered, 'id'>;
+    };
+};
+export declare type IUpdateParamsByIdentifier = Pick<factory.event.IUpdateParams<factory.eventType.ScreeningEvent>, 'additionalProperty' | 'doorTime' | 'endDate' | 'eventStatus' | 'maximumPhysicalAttendeeCapacity' | 'offers' | 'startDate'> & {
+    identifier: string;
+    offers: Pick<factory.event.screeningEvent.IOffers4create, 'eligibleQuantity' | 'seller' | 'unacceptedPaymentMethod'> & {
+        itemOffered: Pick<factory.event.screeningEvent.IItemOffered, 'id'>;
+    };
+    location?: never;
+    superEvent?: never;
+};
 /**
  * イベントサービス
  */
 export declare class EventService extends Service {
+    /**
+     * イベント冪等複数作成
+     * イベントコードをキーにして、存在しなければ作成する
+     */
+    createIfNotExistByIdentifier(params: ICreateParamsByIdentifier[], options: {
+        /**
+         * 施設コンテンツID
+         */
+        superEventId: string;
+        /**
+         * ルームコード
+         */
+        locationBranchCode: string;
+        /**
+         * 座席有無
+         */
+        hasTicketedSeat: boolean;
+        typeOf: factory.eventType.ScreeningEvent;
+    }): Promise<void>;
+    /**
+     * 識別子によるイベント複数更新
+     * 識別子のイベントが存在しなければNotFound
+     * 座席有無は変更できない
+     */
+    updateEventsByIdentifier(params: IUpdateParamsByIdentifier[], options: {
+        typeOf: factory.eventType.ScreeningEvent;
+    }): Promise<void>;
     /**
      * イベント冪等複数作成
      * 特定の追加特性をキーにして、存在しなければ作成する

package/lib/abstract/chevreAdmin/event.js

@@ -63,6 +63,60 @@ var EventService = /** @class */ (function (_super) {
     function EventService() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * イベント冪等複数作成
+     * イベントコードをキーにして、存在しなければ作成する
+     */
+    EventService.prototype.createIfNotExistByIdentifier = function (params, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var superEventId, locationBranchCode, hasTicketedSeat, typeOf;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        superEventId = options.superEventId, locationBranchCode = options.locationBranchCode, hasTicketedSeat = options.hasTicketedSeat, typeOf = options.typeOf;
+                        return [4 /*yield*/, this.fetch({
+                                uri: '/events',
+                                method: 'POST',
+                                body: params,
+                                qs: { superEventId: superEventId, locationBranchCode: locationBranchCode, hasTicketedSeat: hasTicketedSeat, typeOf: typeOf },
+                                expectedStatusCodes: [http_status_1.NO_CONTENT]
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 識別子によるイベント複数更新
+     * 識別子のイベントが存在しなければNotFound
+     * 座席有無は変更できない
+     */
+    EventService.prototype.updateEventsByIdentifier = function (params, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var typeOf;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        typeOf = options.typeOf;
+                        return [4 /*yield*/, this.fetch({
+                                uri: '/events',
+                                method: 'PUT',
+                                body: params,
+                                qs: {
+                                    typeOf: typeOf,
+                                    updateBy: 'identifier'
+                                },
+                                expectedStatusCodes: [http_status_1.NO_CONTENT]
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * イベント冪等複数作成
      * 特定の追加特性をキーにして、存在しなければ作成する

package/lib/abstract/chevreAdmin/note.d.ts

@@ -1,21 +1,61 @@
 import * as factory from '../factory';
 import { Service } from '../service';
 declare type INoteDigitalDocument = factory.creativeWork.noteDigitalDocument.INoteDigitalDocument;
-declare type IKeyOfProjection = keyof INoteDigitalDocument;
-declare type ICreateParams = Pick<INoteDigitalDocument, 'identifier' | 'text'> & {
-    about: Pick<factory.creativeWork.noteDigitalDocument.IAbout, 'id' | 'typeOf'>;
-};
+interface ICreateParams {
+    /**
+     * メモ識別子
+     */
+    identifier: string;
+    /**
+     * メモコンテンツ
+     */
+    text: string;
+    about: {
+        /**
+         * メモの主題リソースID
+         */
+        id: string;
+    };
+}
+interface IDeleteParams {
+    id: string;
+}
+export interface IFindParams {
+    limit: number;
+    page: number;
+    inclusion?: (keyof factory.creativeWork.noteDigitalDocument.INoteDigitalDocument)[];
+    /**
+     * 主題リソースタイプ
+     */
+    aboutTypeOf: factory.creativeWork.noteDigitalDocument.IAbout['typeOf'];
+    /**
+     * 主題リソースIDリスト
+     * max: 10
+     */
+    aboutIds?: string[];
+    /**
+     * メモ識別子リスト
+     * max: 10
+     */
+    identifiers?: string[];
+    /**
+     * メモID
+     */
+    id?: string;
+}
 /**
  * メモサービス
  */
 export declare class NoteService extends Service {
-    upsertByIdentifier(params: ICreateParams[]): Promise<void>;
-    search(params: Omit<factory.creativeWork.noteDigitalDocument.ISearchConditions, 'project'> & {
-        inclusion: IKeyOfProjection[];
-        exclusion: IKeyOfProjection[];
-    }): Promise<(INoteDigitalDocument & {
+    createNotesByIdentifier(params: ICreateParams[], options: {
+        aboutTypeOf: factory.creativeWork.noteDigitalDocument.IAbout['typeOf'];
+    }): Promise<void>;
+    updateNotesByIdentifier(params: ICreateParams[], options: {
+        aboutTypeOf: factory.creativeWork.noteDigitalDocument.IAbout['typeOf'];
+    }): Promise<void>;
+    findNotes(params: IFindParams): Promise<(INoteDigitalDocument & {
         id: string;
     })[]>;
-    updateById(id: string, body: Pick<INoteDigitalDocument, 'text'>): Promise<void>;
+    deleteNotesByIds(params: IDeleteParams[]): Promise<void>;
 }
 export {};