@cinerino/sdk 10.22.0-alpha.2 → 11.0.0-alpha.0

package/lib/abstract/chevreConsole.js

@@ -0,0 +1,1445 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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.ChevreConsole = exports.service = void 0;
+var service;
+(function (service) {
+    var Account;
+    (function (Account) {
+    })(Account = service.Account || (service.Account = {}));
+    var AccountingReport;
+    (function (AccountingReport) {
+    })(AccountingReport = service.AccountingReport || (service.AccountingReport = {}));
+    var AccountTitle;
+    (function (AccountTitle) {
+    })(AccountTitle = service.AccountTitle || (service.AccountTitle = {}));
+    var AccountTransaction;
+    (function (AccountTransaction) {
+    })(AccountTransaction = service.AccountTransaction || (service.AccountTransaction = {}));
+    var Action;
+    (function (Action) {
+    })(Action = service.Action || (service.Action = {}));
+    var AdditionalProperty;
+    (function (AdditionalProperty) {
+    })(AdditionalProperty = service.AdditionalProperty || (service.AdditionalProperty = {}));
+    var AdvanceBookingRequirement;
+    (function (AdvanceBookingRequirement) {
+    })(AdvanceBookingRequirement = service.AdvanceBookingRequirement || (service.AdvanceBookingRequirement = {}));
+    var AggregateOffer;
+    (function (AggregateOffer) {
+    })(AggregateOffer = service.AggregateOffer || (service.AggregateOffer = {}));
+    var AggregateReservation;
+    (function (AggregateReservation) {
+    })(AggregateReservation = service.AggregateReservation || (service.AggregateReservation = {}));
+    var Aggregation;
+    (function (Aggregation) {
+    })(Aggregation = service.Aggregation || (service.Aggregation = {}));
+    var Authorization;
+    (function (Authorization) {
+    })(Authorization = service.Authorization || (service.Authorization = {}));
+    var CategoryCode;
+    (function (CategoryCode) {
+    })(CategoryCode = service.CategoryCode || (service.CategoryCode = {}));
+    var Comment;
+    (function (Comment) {
+    })(Comment = service.Comment || (service.Comment = {}));
+    var CreativeWork;
+    (function (CreativeWork) {
+    })(CreativeWork = service.CreativeWork || (service.CreativeWork = {}));
+    var Customer;
+    (function (Customer) {
+    })(Customer = service.Customer || (service.Customer = {}));
+    var CustomerType;
+    (function (CustomerType) {
+    })(CustomerType = service.CustomerType || (service.CustomerType = {}));
+    var EmailMessage;
+    (function (EmailMessage) {
+    })(EmailMessage = service.EmailMessage || (service.EmailMessage = {}));
+    var Event;
+    (function (Event) {
+    })(Event = service.Event || (service.Event = {}));
+    var EventOffer;
+    (function (EventOffer) {
+    })(EventOffer = service.EventOffer || (service.EventOffer = {}));
+    var EventSeries;
+    (function (EventSeries) {
+    })(EventSeries = service.EventSeries || (service.EventSeries = {}));
+    var HasMerchantReturnPolicy;
+    (function (HasMerchantReturnPolicy) {
+    })(HasMerchantReturnPolicy = service.HasMerchantReturnPolicy || (service.HasMerchantReturnPolicy = {}));
+    var IAM;
+    (function (IAM) {
+    })(IAM = service.IAM || (service.IAM = {}));
+    var Identity;
+    (function (Identity) {
+    })(Identity = service.Identity || (service.Identity = {}));
+    var IdentityProvider;
+    (function (IdentityProvider) {
+    })(IdentityProvider = service.IdentityProvider || (service.IdentityProvider = {}));
+    var Issuer;
+    (function (Issuer) {
+    })(Issuer = service.Issuer || (service.Issuer = {}));
+    var Me;
+    (function (Me) {
+    })(Me = service.Me || (service.Me = {}));
+    var Member;
+    (function (Member) {
+    })(Member = service.Member || (service.Member = {}));
+    var MemberProgram;
+    (function (MemberProgram) {
+    })(MemberProgram = service.MemberProgram || (service.MemberProgram = {}));
+    var MerchantReturnPolicy;
+    (function (MerchantReturnPolicy) {
+    })(MerchantReturnPolicy = service.MerchantReturnPolicy || (service.MerchantReturnPolicy = {}));
+    var Message;
+    (function (Message) {
+    })(Message = service.Message || (service.Message = {}));
+    var Order;
+    (function (Order) {
+    })(Order = service.Order || (service.Order = {}));
+    var OwnershipInfo;
+    (function (OwnershipInfo) {
+    })(OwnershipInfo = service.OwnershipInfo || (service.OwnershipInfo = {}));
+    var PaymentProduct;
+    (function (PaymentProduct) {
+    })(PaymentProduct = service.PaymentProduct || (service.PaymentProduct = {}));
+    var PaymentServiceChannel;
+    (function (PaymentServiceChannel) {
+    })(PaymentServiceChannel = service.PaymentServiceChannel || (service.PaymentServiceChannel = {}));
+    var PendingReservation;
+    (function (PendingReservation) {
+    })(PendingReservation = service.PendingReservation || (service.PendingReservation = {}));
+    var Permission;
+    (function (Permission) {
+    })(Permission = service.Permission || (service.Permission = {}));
+    var Permit;
+    (function (Permit) {
+    })(Permit = service.Permit || (service.Permit = {}));
+    var Person;
+    (function (Person) {
+    })(Person = service.Person || (service.Person = {}));
+    var person;
+    (function (person) {
+        // tslint:disable-next-line:no-shadowed-variable
+        var OwnershipInfo;
+        (function (OwnershipInfo) {
+        })(OwnershipInfo = person.OwnershipInfo || (person.OwnershipInfo = {}));
+    })(person = service.person || (service.person = {}));
+    var Place;
+    (function (Place) {
+    })(Place = service.Place || (service.Place = {}));
+    var place;
+    (function (place) {
+        var HasPOS;
+        (function (HasPOS) {
+        })(HasPOS = place.HasPOS || (place.HasPOS = {}));
+    })(place = service.place || (service.place = {}));
+    var PriceSpecification;
+    (function (PriceSpecification) {
+    })(PriceSpecification = service.PriceSpecification || (service.PriceSpecification = {}));
+    var Product;
+    (function (Product) {
+    })(Product = service.Product || (service.Product = {}));
+    var ProductModel;
+    (function (ProductModel) {
+    })(ProductModel = service.ProductModel || (service.ProductModel = {}));
+    var Project;
+    (function (Project) {
+    })(Project = service.Project || (service.Project = {}));
+    var ProjectMakesOffer;
+    (function (ProjectMakesOffer) {
+    })(ProjectMakesOffer = service.ProjectMakesOffer || (service.ProjectMakesOffer = {}));
+    var Reservation;
+    (function (Reservation) {
+    })(Reservation = service.Reservation || (service.Reservation = {}));
+    var Offer;
+    (function (Offer) {
+    })(Offer = service.Offer || (service.Offer = {}));
+    var OfferCatalog;
+    (function (OfferCatalog) {
+    })(OfferCatalog = service.OfferCatalog || (service.OfferCatalog = {}));
+    var OfferCatalogItem;
+    (function (OfferCatalogItem) {
+    })(OfferCatalogItem = service.OfferCatalogItem || (service.OfferCatalogItem = {}));
+    var OfferItemCondition;
+    (function (OfferItemCondition) {
+    })(OfferItemCondition = service.OfferItemCondition || (service.OfferItemCondition = {}));
+    var Seller;
+    (function (Seller) {
+    })(Seller = service.Seller || (service.Seller = {}));
+    var SellerReturnPolicy;
+    (function (SellerReturnPolicy) {
+    })(SellerReturnPolicy = service.SellerReturnPolicy || (service.SellerReturnPolicy = {}));
+    var Task;
+    (function (Task) {
+    })(Task = service.Task || (service.Task = {}));
+    var Ticket;
+    (function (Ticket) {
+    })(Ticket = service.Ticket || (service.Ticket = {}));
+    var AssetTransaction;
+    (function (AssetTransaction) {
+    })(AssetTransaction = service.AssetTransaction || (service.AssetTransaction = {}));
+    var assetTransaction;
+    (function (assetTransaction) {
+        var MoneyTransfer;
+        (function (MoneyTransfer) {
+        })(MoneyTransfer = assetTransaction.MoneyTransfer || (assetTransaction.MoneyTransfer = {}));
+        var Pay;
+        (function (Pay) {
+        })(Pay = assetTransaction.Pay || (assetTransaction.Pay = {}));
+        var RegisterService;
+        (function (RegisterService) {
+        })(RegisterService = assetTransaction.RegisterService || (assetTransaction.RegisterService = {}));
+        var Reserve;
+        (function (Reserve) {
+        })(Reserve = assetTransaction.Reserve || (assetTransaction.Reserve = {}));
+    })(assetTransaction = service.assetTransaction || (service.assetTransaction = {}));
+    var Token;
+    (function (Token) {
+    })(Token = service.Token || (service.Token = {}));
+    /**
+     * 取引サービス
+     */
+    var transaction;
+    (function (transaction) {
+        var MoneyTransfer;
+        (function (MoneyTransfer) {
+        })(MoneyTransfer = transaction.MoneyTransfer || (transaction.MoneyTransfer = {}));
+        var PlaceOrder;
+        (function (PlaceOrder) {
+        })(PlaceOrder = transaction.PlaceOrder || (transaction.PlaceOrder = {}));
+        var ReturnOrder;
+        (function (ReturnOrder) {
+        })(ReturnOrder = transaction.ReturnOrder || (transaction.ReturnOrder = {}));
+    })(transaction = service.transaction || (service.transaction = {}));
+    var TransactionNumber;
+    (function (TransactionNumber) {
+    })(TransactionNumber = service.TransactionNumber || (service.TransactionNumber = {}));
+    var Trip;
+    (function (Trip) {
+    })(Trip = service.Trip || (service.Trip = {}));
+    var UserPool;
+    (function (UserPool) {
+    })(UserPool = service.UserPool || (service.UserPool = {}));
+    var WebSite;
+    (function (WebSite) {
+    })(WebSite = service.WebSite || (service.WebSite = {}));
+})(service = exports.service || (exports.service = {}));
+/**
+ * コンソールサービス
+ */
+var ChevreConsole = /** @class */ (function () {
+    function ChevreConsole(options) {
+        this.options = options;
+    }
+    ChevreConsole.prototype.createAccountInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Account.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Account;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/account'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).AccountService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Account.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createAccountingReportInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.AccountingReport.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.AccountingReport;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/accountingReport'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).AccountingReportService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.AccountingReport.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createAccountTitleInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.AccountTitle.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.AccountTitle;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/accountTitle'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).AccountTitleService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.AccountTitle.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createAccountTransactionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.AccountTransaction.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.AccountTransaction;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/accountTransaction'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).AccountTransactionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.AccountTransaction.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createActionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Action.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Action;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/action'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).ActionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Action.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createAdditionalPropertyInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.AdditionalProperty.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.AdditionalProperty;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/additionalProperty'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).AdditionalPropertyService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.AdditionalProperty.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createAdvanceBookingRequirementInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.AdvanceBookingRequirement.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.AdvanceBookingRequirement;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/advanceBookingRequirement'); })];
+                    case 1:
+                        _a.svc =
+                            (_b.sent()).AdvanceBookingRequirementService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.AdvanceBookingRequirement.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createAggregateOfferInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.AggregateOffer.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.AggregateOffer;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/aggregateOffer'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).AggregateOfferService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.AggregateOffer.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createAggregateReservationInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.AggregateReservation.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.AggregateReservation;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/aggregateReservation'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).AggregateReservationService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.AggregateReservation.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createAggregationInstance = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Aggregation.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Aggregation;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/aggregation'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).AggregationService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Aggregation.svc(__assign({}, this.options))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createAuthorizationInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Authorization.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Authorization;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/authorization'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).AuthorizationService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Authorization.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createCommentInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Comment.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Comment;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/comment'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).CommentService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Comment.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createCreativeWorkInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.CreativeWork.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.CreativeWork;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/creativeWork'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).CreativeWorkService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.CreativeWork.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createCategoryCodeInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.CategoryCode.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.CategoryCode;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/categoryCode'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).CategoryCodeService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.CategoryCode.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createCustomerInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Customer.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Customer;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/customer'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).CustomerService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Customer.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createCustomerTypeInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.CustomerType.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.CustomerType;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/customerType'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).CustomerTypeService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.CustomerType.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createEmailMessageInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.EmailMessage.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.EmailMessage;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/emailMessage'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).EmailMessageService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.EmailMessage.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createEventInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Event.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Event;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/event'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).EventService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Event.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createEventOfferInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.EventOffer.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.EventOffer;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/eventOffer'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).EventOfferService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.EventOffer.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createEventSeriesInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.EventSeries.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.EventSeries;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/eventSeries'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).EventSeriesService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.EventSeries.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createHasMerchantReturnPolicyInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.HasMerchantReturnPolicy.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.HasMerchantReturnPolicy;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/hasMerchantReturnPolicy'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).HasMerchantReturnPolicyService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.HasMerchantReturnPolicy.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createIAMInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.IAM.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.IAM;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/iam'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).IAMService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.IAM.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createIdentityInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Identity.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Identity;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/identity'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).IdentityService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Identity.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createIdentityProviderInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.IdentityProvider.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.IdentityProvider;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/identityProvider'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).IdentityProviderService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.IdentityProvider.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createIssuerInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Issuer.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Issuer;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/issuer'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).IssuerService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Issuer.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createMeInstance = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Me.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Me;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/me'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).MeService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Me.svc(__assign({}, this.options))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createMemberInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Member.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Member;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/member'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).MemberService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Member.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createMemberProgramInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.MemberProgram.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.MemberProgram;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/memberProgram'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).MemberProgramService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.MemberProgram.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createMerchantReturnPolicyInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.MerchantReturnPolicy.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.MerchantReturnPolicy;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/merchantReturnPolicy'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).MerchantReturnPolicyService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.MerchantReturnPolicy.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createMessageInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Message.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Message;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/message'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).MessageService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Message.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createOrderInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Order.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Order;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/order'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).OrderService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Order.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createOwnershipInfoInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.OwnershipInfo.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.OwnershipInfo;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/ownershipInfo'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).OwnershipInfoService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.OwnershipInfo.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createPaymentProductInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.PaymentProduct.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.PaymentProduct;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/paymentService'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).PaymentProductService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.PaymentProduct.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createPaymentServiceChannelInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.PaymentServiceChannel.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.PaymentServiceChannel;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/paymentServiceChannel'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).PaymentServiceChannelService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.PaymentServiceChannel.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createPendingReservationInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.PendingReservation.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.PendingReservation;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/pendingReservation'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).PendingReservationService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.PendingReservation.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createPermissionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Permission.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Permission;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/permission'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).PermissionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Permission.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createPermitInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Permit.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Permit;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/permit'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).PermitService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Permit.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createPersonInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Person.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Person;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/person'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).PersonService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Person.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createPersonOwnershipInfoInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.person.OwnershipInfo.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.person.OwnershipInfo;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/person/ownershipInfo'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).PersonOwnershipInfoService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.person.OwnershipInfo.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createPlaceInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Place.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Place;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/place'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).PlaceService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Place.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createHasPOSInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.place.HasPOS.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.place.HasPOS;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/place/hasPOS'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).HasPOSService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.place.HasPOS.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createPriceSpecificationInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.PriceSpecification.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.PriceSpecification;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/priceSpecification'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).PriceSpecificationService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.PriceSpecification.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createProductInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Product.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Product;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/product'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).ProductService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Product.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createProductModelInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.ProductModel.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.ProductModel;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/productModel'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).ProductModelService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.ProductModel.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createProjectInstance = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Project.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Project;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/project'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).ProjectService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Project.svc(__assign({}, this.options))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createProjectMakesOfferInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.ProjectMakesOffer.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.ProjectMakesOffer;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/projectMakesOffer'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).ProjectMakesOfferService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.ProjectMakesOffer.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createReservationInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Reservation.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Reservation;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/reservation'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).ReservationService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Reservation.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createOfferInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Offer.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Offer;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/offer'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).OfferService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Offer.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createOfferCatalogInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.OfferCatalog.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.OfferCatalog;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/offerCatalog'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).OfferCatalogService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.OfferCatalog.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createOfferCatalogItemInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.OfferCatalogItem.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.OfferCatalogItem;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/offerCatalogItem'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).OfferCatalogItemService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.OfferCatalogItem.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createOfferItemConditionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.OfferItemCondition.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.OfferItemCondition;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/offerItemCondition'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).OfferItemConditionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.OfferItemCondition.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createSellerInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Seller.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Seller;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/seller'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).SellerService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Seller.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createSellerReturnPolicyInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.SellerReturnPolicy.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.SellerReturnPolicy;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/sellerReturnPolicy'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).SellerReturnPolicyService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.SellerReturnPolicy.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createTaskInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Task.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Task;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/task'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).TaskService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Task.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createTicketInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Ticket.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Ticket;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/ticket'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).TicketService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Ticket.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createAssetTransactionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.AssetTransaction.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.AssetTransaction;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/assetTransaction'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).AssetTransactionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.AssetTransaction.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createMoneyTransferAssetTransactionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.assetTransaction.MoneyTransfer.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.assetTransaction.MoneyTransfer;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/assetTransaction/moneyTransfer'); })];
+                    case 1:
+                        _a.svc =
+                            (_b.sent()).MoneyTransferAssetTransactionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.assetTransaction.MoneyTransfer.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createPayAssetTransactionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.assetTransaction.Pay.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.assetTransaction.Pay;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/assetTransaction/pay'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).PayAssetTransactionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.assetTransaction.Pay.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createRegisterServiceAssetTransactionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.assetTransaction.RegisterService.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.assetTransaction.RegisterService;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/assetTransaction/registerService'); })];
+                    case 1:
+                        _a.svc =
+                            (_b.sent()).RegisterServiceAssetTransactionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.assetTransaction.RegisterService.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createReserveAssetTransactionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.assetTransaction.Reserve.svc === undefined)) return [3 /*break*/, 2];
+                        // tslint:disable-next-line:max-line-length
+                        _a = service.assetTransaction.Reserve;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/assetTransaction/reserve'); })];
+                    case 1:
+                        // tslint:disable-next-line:max-line-length
+                        _a.svc = (_b.sent()).ReserveAssetTransactionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.assetTransaction.Reserve.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createTokenInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Token.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Token;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/token'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).TokenService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Token.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createMoneyTransferTransactionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.transaction.MoneyTransfer.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.transaction.MoneyTransfer;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/transaction/moneyTransfer'); })];
+                    case 1:
+                        _a.svc =
+                            (_b.sent()).MoneyTransferTransactionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.transaction.MoneyTransfer.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createPlaceOrderTransactionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.transaction.PlaceOrder.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.transaction.PlaceOrder;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/transaction/placeOrder'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).PlaceOrderTransactionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.transaction.PlaceOrder.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createReturnOrderTransactionInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.transaction.ReturnOrder.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.transaction.ReturnOrder;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/transaction/returnOrder'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).ReturnOrderTransactionService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.transaction.ReturnOrder.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createTransactionNumberInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.TransactionNumber.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.TransactionNumber;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/transactionNumber'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).TransactionNumberService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.TransactionNumber.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createTripInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.Trip.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.Trip;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/trip'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).TripService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.Trip.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createUserPoolInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.UserPool.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.UserPool;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/userPool'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).UserPoolService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.UserPool.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    ChevreConsole.prototype.createWebSiteInstance = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(service.WebSite.svc === undefined)) return [3 /*break*/, 2];
+                        _a = service.WebSite;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('./chevreConsole/webSite'); })];
+                    case 1:
+                        _a.svc = (_b.sent()).WebSiteService;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new service.WebSite.svc(__assign(__assign(__assign({}, this.options), params), { retryableStatusCodes: [] }))];
+                }
+            });
+        });
+    };
+    return ChevreConsole;
+}());
+exports.ChevreConsole = ChevreConsole;