@dereekb/trello 13.11.14

package/index.cjs.js

@@ -0,0 +1,1629 @@
+'use strict';
+
+var fetch = require('@dereekb/util/fetch');
+var makeError = require('make-error');
+var util = require('@dereekb/util');
+
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+function _ts_generator$3(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: 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(g && (g = 0, op[0] && (_ = 0)), _)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
+        };
+    }
+}
+/**
+ * Base Trello server error.
+ */ var TrelloServerError = /*#__PURE__*/ function(BaseError) {
+    _inherits(TrelloServerError, BaseError);
+    function TrelloServerError(message, data) {
+        _class_call_check(this, TrelloServerError);
+        var _this;
+        _this = _call_super(this, TrelloServerError, [
+            message
+        ]), _define_property$2(_this, "data", void 0);
+        _this.data = data;
+        return _this;
+    }
+    _create_class(TrelloServerError, [
+        {
+            key: "status",
+            get: function get() {
+                return this.data.status;
+            }
+        }
+    ]);
+    return TrelloServerError;
+}(makeError.BaseError);
+/**
+ * Trello server error that retains the originating fetch response.
+ */ var TrelloServerFetchResponseError = /*#__PURE__*/ function(TrelloServerError) {
+    _inherits(TrelloServerFetchResponseError, TrelloServerError);
+    function TrelloServerFetchResponseError(message, data, responseError) {
+        _class_call_check(this, TrelloServerFetchResponseError);
+        var _this;
+        _this = _call_super(this, TrelloServerFetchResponseError, [
+            message,
+            data
+        ]), _define_property$2(_this, "responseError", void 0);
+        _this.responseError = responseError;
+        return _this;
+    }
+    return TrelloServerFetchResponseError;
+}(TrelloServerError);
+/**
+ * Trello returned 401 — typically a revoked or otherwise invalid token.
+ *
+ * @see https://developer.atlassian.com/cloud/trello/guides/rest-api/authorization/
+ */ var TrelloInvalidTokenError = /*#__PURE__*/ function(TrelloServerFetchResponseError) {
+    _inherits(TrelloInvalidTokenError, TrelloServerFetchResponseError);
+    function TrelloInvalidTokenError() {
+        _class_call_check(this, TrelloInvalidTokenError);
+        return _call_super(this, TrelloInvalidTokenError, arguments);
+    }
+    return TrelloInvalidTokenError;
+}(TrelloServerFetchResponseError);
+/**
+ * Trello returned 429 — too many requests.
+ */ var TrelloTooManyRequestsError = /*#__PURE__*/ function(TrelloServerFetchResponseError) {
+    _inherits(TrelloTooManyRequestsError, TrelloServerFetchResponseError);
+    function TrelloTooManyRequestsError() {
+        _class_call_check(this, TrelloTooManyRequestsError);
+        return _call_super(this, TrelloTooManyRequestsError, arguments);
+    }
+    _create_class(TrelloTooManyRequestsError, [
+        {
+            key: "retryAfter",
+            get: function get() {
+                var headerValue = this.responseError.response.headers.get('Retry-After');
+                return headerValue ? Number(headerValue) : undefined;
+            }
+        }
+    ]);
+    return TrelloTooManyRequestsError;
+}(TrelloServerFetchResponseError);
+/**
+ * Creates a logTrelloServerErrorFunction that logs the error to console.
+ *
+ * @param trelloApiNamePrefix Prefix to use when logging.
+ * @returns A function that logs Trello server errors to the console.
+ * @__NO_SIDE_EFFECTS__
+ */ function logTrelloServerErrorFunction(trelloApiNamePrefix) {
+    return function(error) {
+        if (_instanceof(error, TrelloServerFetchResponseError)) {
+            console.log("".concat(trelloApiNamePrefix, "Error(").concat(error.responseError.response.status, "): "), {
+                error: error,
+                errorData: error.data
+            });
+        } else if (_instanceof(error, TrelloServerError)) {
+            console.log("".concat(trelloApiNamePrefix, "Error(status:").concat(error.status, "): "), {
+                error: error
+            });
+        } else {
+            console.log("".concat(trelloApiNamePrefix, "Error(name:").concat(error.name, "): "), {
+                error: error
+            });
+        }
+    };
+}
+var logTrelloErrorToConsole = logTrelloServerErrorFunction('Trello');
+/**
+ * Parses a FetchResponseError into a typed Trello API error.
+ *
+ * @param responseError The fetch response error to parse.
+ * @returns A typed Trello error, or undefined if the response could not be parsed.
+ */ function parseTrelloApiError(responseError) {
+    return _async_to_generator$3(function() {
+        var response, bodyText, bodyJson, data, message, result;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    response = responseError.response;
+                    return [
+                        4,
+                        response.clone().text().catch(function() {
+                            return '';
+                        })
+                    ];
+                case 1:
+                    bodyText = _state.sent();
+                    try {
+                        bodyJson = bodyText ? JSON.parse(bodyText) : undefined;
+                    } catch (unused) {
+                        bodyJson = undefined;
+                    }
+                    data = {
+                        status: response.status,
+                        bodyText: bodyText,
+                        bodyJson: bodyJson
+                    };
+                    message = bodyText || "Trello request failed with status ".concat(response.status);
+                    switch(response.status){
+                        case 401:
+                            result = new TrelloInvalidTokenError(message, data, responseError);
+                            break;
+                        case 429:
+                            result = new TrelloTooManyRequestsError(message, data, responseError);
+                            break;
+                        default:
+                            result = new TrelloServerFetchResponseError(message, data, responseError);
+                            break;
+                    }
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Wraps a ConfiguredFetch to translate FetchResponseError into typed Trello errors.
+ *
+ * @param fetch The fetch to wrap.
+ * @param logError Optional logger.
+ * @returns A ConfiguredFetch that throws typed Trello errors for known error responses.
+ * @__NO_SIDE_EFFECTS__
+ */ function handleTrelloErrorFetch(fetch$1) {
+    var logError = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : logTrelloErrorToConsole;
+    return function(x, y) {
+        return _async_to_generator$3(function() {
+            var e, error;
+            return _ts_generator$3(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            2,
+                            ,
+                            5
+                        ]);
+                        return [
+                            4,
+                            fetch$1(x, y)
+                        ];
+                    case 1:
+                        return [
+                            2,
+                            _state.sent()
+                        ];
+                    case 2:
+                        e = _state.sent();
+                        if (!_instanceof(e, fetch.FetchResponseError)) return [
+                            3,
+                            4
+                        ];
+                        return [
+                            4,
+                            parseTrelloApiError(e)
+                        ];
+                    case 3:
+                        error = _state.sent();
+                        if (error) {
+                            logError(error);
+                            throw error;
+                        }
+                        _state.label = 4;
+                    case 4:
+                        throw e;
+                    case 5:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    };
+}
+
+/**
+ * Documented per-token rate limit: 100 requests per 10 seconds.
+ *
+ * @see https://developer.atlassian.com/cloud/trello/guides/rest-api/rate-limits/
+ */ var DEFAULT_TRELLO_API_RATE_LIMIT = 100;
+/**
+ * Reset period for the per-token rate limit (10 seconds).
+ */ var DEFAULT_TRELLO_API_RATE_LIMIT_RESET_PERIOD = util.MS_IN_SECOND * 10;
+/**
+ * Creates a rate-limited fetch handler configured for the Trello API.
+ *
+ * Backs off after 429 responses and respects the documented per-token rate limit.
+ *
+ * @param config Optional configuration for rate limiting behavior.
+ * @returns A configured rate-limited fetch handler.
+ * @__NO_SIDE_EFFECTS__
+ */ function trelloRateLimitedFetchHandler(config) {
+    var _ref, _ref1;
+    var limit = (_ref = config === null || config === void 0 ? void 0 : config.maxRateLimit) !== null && _ref !== void 0 ? _ref : DEFAULT_TRELLO_API_RATE_LIMIT;
+    var resetPeriod = (_ref1 = config === null || config === void 0 ? void 0 : config.resetPeriod) !== null && _ref1 !== void 0 ? _ref1 : DEFAULT_TRELLO_API_RATE_LIMIT_RESET_PERIOD;
+    var rateLimiter = util.resetPeriodPromiseRateLimiter({
+        limit: limit,
+        startLimitAt: Math.max(2, Math.ceil(limit / 10)),
+        cooldownRate: 1,
+        exponentRate: 1.1,
+        maxWaitTime: util.MS_IN_SECOND * 10,
+        resetPeriod: resetPeriod
+    });
+    return fetch.rateLimitedFetchHandler({
+        rateLimiter: rateLimiter,
+        updateWithResponse: function updateWithResponse(response) {
+            // Trello does not document rate limit headers, but it does return 429 when exceeded.
+            // Schedule a retry after the rate limiter cooldown when a 429 is observed.
+            if (response.status === 429) {
+                return true;
+            }
+            return false;
+        }
+    });
+}
+
+/**
+ * Trello API URL (versioned).
+ */ var TRELLO_API_URL = 'https://api.trello.com/1';
+
+/**
+ * Builds a Trello API factory.
+ *
+ * Auth uses Trello's `Authorization: OAuth oauth_consumer_key=..., oauth_token=...` header form so credentials never appear in URLs or logs.
+ *
+ * @param factoryConfig Factory-level configuration shared across created Trello instances.
+ * @returns A factory function that creates a configured Trello API instance.
+ * @__NO_SIDE_EFFECTS__
+ */ function trelloFactory() {
+    var factoryConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var logTrelloServerErrorFunction = factoryConfig.logTrelloServerErrorFunction;
+    var fetchHandler = trelloRateLimitedFetchHandler(factoryConfig.rateLimiterConfig);
+    return function(config) {
+        var _config_apiUrl;
+        var authHeader = 'OAuth oauth_consumer_key="'.concat(config.apiKey, '", oauth_token="').concat(config.apiToken, '"');
+        var baseFetch = fetch.fetchApiFetchService.makeFetch({
+            baseUrl: (_config_apiUrl = config.apiUrl) !== null && _config_apiUrl !== void 0 ? _config_apiUrl : TRELLO_API_URL,
+            baseRequest: function baseRequest() {
+                return {
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: authHeader
+                    }
+                };
+            },
+            fetchHandler: fetchHandler,
+            timeout: 20 * 1000,
+            requireOkResponse: true,
+            useTimeout: true
+        });
+        var fetch$1 = handleTrelloErrorFetch(baseFetch, logTrelloServerErrorFunction);
+        var fetchJsonInst = fetch.fetchJsonFunction(fetch$1, {
+            handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
+        });
+        var trelloContext = {
+            fetch: fetch$1,
+            fetchJson: fetchJsonInst,
+            config: config,
+            trelloRateLimiter: fetchHandler._rateLimiter
+        };
+        var trello = {
+            trelloContext: trelloContext
+        };
+        return trello;
+    };
+}
+
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _object_without_properties$3(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys, key, i;
+    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
+        sourceKeys = Reflect.ownKeys(Object(source));
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+        return target;
+    }
+    target = _object_without_properties_loose$3(source, excluded);
+    if (Object.getOwnPropertySymbols) {
+        sourceKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose$3(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _ts_generator$2(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: 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(g && (g = 0, op[0] && (_ = 0)), _)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
+        };
+    }
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-boards/#api-boards-id-get
+ *
+ * @param context The Trello API context.
+ * @returns A function that retrieves a board by id.
+ */ function getBoard(context) {
+    return function(input) {
+        return context.fetchJson("/boards/".concat(input.boardId), 'GET');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-boards/#api-boards-post
+ *
+ * @param context The Trello API context.
+ * @returns A function that creates a new board.
+ */ function createBoard(context) {
+    return function(input) {
+        var queryString = fetch.makeUrlSearchParams(input);
+        return context.fetchJson("/boards?".concat(queryString), 'POST');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-boards/#api-boards-id-put
+ *
+ * @param context The Trello API context.
+ * @returns A function that updates an existing board.
+ */ function updateBoard(context) {
+    return function(input) {
+        var boardId = input.boardId, body = _object_without_properties$3(input, [
+            "boardId"
+        ]);
+        return context.fetchJson("/boards/".concat(boardId), 'PUT', body);
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-boards/#api-boards-id-delete
+ *
+ * @param context The Trello API context.
+ * @returns A function that deletes a board.
+ */ function deleteBoard(context) {
+    return function(input) {
+        return _async_to_generator$2(function() {
+            return _ts_generator$2(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            context.fetchJson("/boards/".concat(input.boardId), 'DELETE')
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-boards/#api-boards-id-lists-get
+ *
+ * @param context The Trello API context.
+ * @returns A function that lists all lists on a board.
+ */ function listBoardLists(context) {
+    return function(input) {
+        var boardId = input.boardId, query = _object_without_properties$3(input, [
+            "boardId"
+        ]);
+        var queryString = fetch.makeUrlSearchParams(query);
+        return context.fetchJson("/boards/".concat(boardId, "/lists?").concat(queryString), 'GET');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-boards/#api-boards-id-cards-get
+ *
+ * @param context The Trello API context.
+ * @returns A function that lists all cards on a board.
+ */ function listBoardCards(context) {
+    return function(input) {
+        var boardId = input.boardId, query = _object_without_properties$3(input, [
+            "boardId"
+        ]);
+        var queryString = fetch.makeUrlSearchParams(query);
+        return context.fetchJson("/boards/".concat(boardId, "/cards?").concat(queryString), 'GET');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-boards/#api-boards-id-labels-get
+ *
+ * @param context The Trello API context.
+ * @returns A function that lists every label defined on a board.
+ */ function listBoardLabels(context) {
+    return function(input) {
+        var boardId = input.boardId, query = _object_without_properties$3(input, [
+            "boardId"
+        ]);
+        var queryString = fetch.makeUrlSearchParams(query);
+        return context.fetchJson("/boards/".concat(boardId, "/labels?").concat(queryString), 'GET');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-boards/#api-boards-id-members-get
+ *
+ * @param context The Trello API context.
+ * @returns A function that lists all members of a board.
+ */ function listBoardMembers(context) {
+    return function(input) {
+        return context.fetchJson("/boards/".concat(input.boardId, "/members"), 'GET');
+    };
+}
+
+function _object_without_properties$2(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys, key, i;
+    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
+        sourceKeys = Reflect.ownKeys(Object(source));
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+        return target;
+    }
+    target = _object_without_properties_loose$2(source, excluded);
+    if (Object.getOwnPropertySymbols) {
+        sourceKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose$2(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-lists/#api-lists-id-get
+ *
+ * @param context The Trello API context.
+ * @returns A function that retrieves a list by id.
+ */ function getList(context) {
+    return function(input) {
+        return context.fetchJson("/lists/".concat(input.listId), 'GET');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-lists/#api-lists-post
+ *
+ * @param context The Trello API context.
+ * @returns A function that creates a new list on a board.
+ */ function createList(context) {
+    return function(input) {
+        var queryString = fetch.makeUrlSearchParams(input);
+        return context.fetchJson("/lists?".concat(queryString), 'POST');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-lists/#api-lists-id-put
+ *
+ * @param context The Trello API context.
+ * @returns A function that updates an existing list.
+ */ function updateList(context) {
+    return function(input) {
+        var listId = input.listId, body = _object_without_properties$2(input, [
+            "listId"
+        ]);
+        return context.fetchJson("/lists/".concat(listId), 'PUT', body);
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-lists/#api-lists-id-cards-get
+ *
+ * @param context The Trello API context.
+ * @returns A function that lists all cards on a list.
+ */ function listCardsInList(context) {
+    return function(input) {
+        var listId = input.listId, query = _object_without_properties$2(input, [
+            "listId"
+        ]);
+        var queryString = fetch.makeUrlSearchParams(query);
+        return context.fetchJson("/lists/".concat(listId, "/cards?").concat(queryString), 'GET');
+    };
+}
+
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$1(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$1(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _object_without_properties$1(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys, key, i;
+    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
+        sourceKeys = Reflect.ownKeys(Object(source));
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+        return target;
+    }
+    target = _object_without_properties_loose$1(source, excluded);
+    if (Object.getOwnPropertySymbols) {
+        sourceKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose$1(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: 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(g && (g = 0, op[0] && (_ = 0)), _)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
+        };
+    }
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-cards/#api-cards-id-get
+ *
+ * @param context The Trello API context.
+ * @returns A function that retrieves a card by id.
+ */ function getCard(context) {
+    return function(input) {
+        return context.fetchJson("/cards/".concat(input.cardId), 'GET');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-cards/#api-cards-post
+ *
+ * @param context The Trello API context.
+ * @returns A function that creates a card on a list.
+ */ function createCard(context) {
+    return function(input) {
+        var idLabels = input.idLabels, idMembers = input.idMembers, rest = _object_without_properties$1(input, [
+            "idLabels",
+            "idMembers"
+        ]);
+        var query = _object_spread$1({}, rest);
+        if (idLabels) {
+            query.idLabels = idLabels.join(',');
+        }
+        if (idMembers) {
+            query.idMembers = idMembers.join(',');
+        }
+        var queryString = fetch.makeUrlSearchParams(query);
+        return context.fetchJson("/cards?".concat(queryString), 'POST');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-cards/#api-cards-id-put
+ *
+ * @param context The Trello API context.
+ * @returns A function that updates an existing card.
+ */ function updateCard(context) {
+    return function(input) {
+        var cardId = input.cardId, idLabels = input.idLabels, idMembers = input.idMembers, rest = _object_without_properties$1(input, [
+            "cardId",
+            "idLabels",
+            "idMembers"
+        ]);
+        var body = _object_spread$1({}, rest);
+        if (idLabels) {
+            body.idLabels = idLabels.join(',');
+        }
+        if (idMembers) {
+            body.idMembers = idMembers.join(',');
+        }
+        return context.fetchJson("/cards/".concat(cardId), 'PUT', body);
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-cards/#api-cards-id-delete
+ *
+ * @param context The Trello API context.
+ * @returns A function that deletes a card.
+ */ function deleteCard(context) {
+    return function(input) {
+        return _async_to_generator$1(function() {
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            context.fetchJson("/cards/".concat(input.cardId), 'DELETE')
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-cards/#api-cards-id-actions-get
+ *
+ * Comments are returned as actions with `type === 'commentCard'`; pass `filter: 'commentCard'` and the generic
+ * type parameter `TrelloCommentCardActionData` to get a comment-typed result.
+ *
+ * @param context The Trello API context.
+ * @returns A function that lists actions on a card.
+ */ function listCardActions(context) {
+    return function(input) {
+        var cardId = input.cardId, query = _object_without_properties$1(input, [
+            "cardId"
+        ]);
+        var queryString = fetch.makeUrlSearchParams(query);
+        return context.fetchJson("/cards/".concat(cardId, "/actions?").concat(queryString), 'GET');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-cards/#api-cards-id-actions-comments-post
+ *
+ * @param context The Trello API context.
+ * @returns A function that adds a comment to a card.
+ */ function addCommentToCard(context) {
+    return function(input) {
+        var queryString = fetch.makeUrlSearchParams({
+            text: input.text
+        });
+        return context.fetchJson("/cards/".concat(input.cardId, "/actions/comments?").concat(queryString), 'POST');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-cards/#api-cards-id-idmembers-post
+ *
+ * @param context The Trello API context.
+ * @returns A function that adds a member to a card.
+ */ function addMemberToCard(context) {
+    return function(input) {
+        var queryString = fetch.makeUrlSearchParams({
+            value: input.memberId
+        });
+        return context.fetchJson("/cards/".concat(input.cardId, "/idMembers?").concat(queryString), 'POST');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-cards/#api-cards-id-idlabels-post
+ *
+ * @param context The Trello API context.
+ * @returns A function that adds an existing label to a card.
+ */ function addLabelToCard(context) {
+    return function(input) {
+        var queryString = fetch.makeUrlSearchParams({
+            value: input.labelId
+        });
+        return context.fetchJson("/cards/".concat(input.cardId, "/idLabels?").concat(queryString), 'POST');
+    };
+}
+
+/**
+ * https://developer.atlassian.com/cloud/trello/rest/api-group-members/#api-members-id-get
+ *
+ * @param context The Trello API context.
+ * @returns A function that retrieves a member by id (or `me`).
+ */ function getMember(context) {
+    return function(input) {
+        return context.fetchJson("/members/".concat(input.memberId), 'GET');
+    };
+}
+/**
+ * Convenience wrapper around `getMember({ memberId: 'me' })`.
+ *
+ * @param context The Trello API context.
+ * @returns A function that retrieves the authenticated user.
+ */ function getMe(context) {
+    return function() {
+        return context.fetchJson("/members/me", 'GET');
+    };
+}
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys, key, i;
+    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
+        sourceKeys = Reflect.ownKeys(Object(source));
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+        return target;
+    }
+    target = _object_without_properties_loose(source, excluded);
+    if (Object.getOwnPropertySymbols) {
+        sourceKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: 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(g && (g = 0, op[0] && (_ = 0)), _)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
+        };
+    }
+}
+/**
+ * Trello validates the callback URL with a HEAD request before creation. The endpoint MUST return 200.
+ *
+ * https://developer.atlassian.com/cloud/trello/guides/rest-api/webhooks/#creating-a-webhook
+ *
+ * @param context The Trello API context.
+ * @returns A function that registers a new webhook.
+ */ function createWebhook(context) {
+    return function(input) {
+        var queryString = fetch.makeUrlSearchParams(input);
+        return context.fetchJson("/webhooks?".concat(queryString), 'POST');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/guides/rest-api/webhooks/#retrieving-a-webhook
+ *
+ * @param context The Trello API context.
+ * @returns A function that retrieves a webhook by id.
+ */ function getWebhook(context) {
+    return function(input) {
+        return context.fetchJson("/webhooks/".concat(input.webhookId), 'GET');
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/guides/rest-api/webhooks/#updating-a-webhook
+ *
+ * @param context The Trello API context.
+ * @returns A function that updates an existing webhook.
+ */ function updateWebhook(context) {
+    return function(input) {
+        var webhookId = input.webhookId, body = _object_without_properties(input, [
+            "webhookId"
+        ]);
+        return context.fetchJson("/webhooks/".concat(webhookId), 'PUT', body);
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/guides/rest-api/webhooks/#deleting-a-webhook
+ *
+ * @param context The Trello API context.
+ * @returns A function that deletes a webhook.
+ */ function deleteWebhook(context) {
+    return function(input) {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            context.fetchJson("/webhooks/".concat(input.webhookId), 'DELETE')
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    };
+}
+/**
+ * https://developer.atlassian.com/cloud/trello/guides/rest-api/webhooks/
+ *
+ * @param context The Trello API context.
+ * @returns A function that lists all webhooks registered for a token.
+ */ function listWebhooksForToken(context) {
+    return function(input) {
+        var _ref;
+        var token = (_ref = input === null || input === void 0 ? void 0 : input.apiToken) !== null && _ref !== void 0 ? _ref : context.config.apiToken;
+        return context.fetchJson("/tokens/".concat(token, "/webhooks"), 'GET');
+    };
+}
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+/**
+ * Maximum allowed `limit` value for most Trello collection endpoints.
+ *
+ * @see https://developer.atlassian.com/cloud/trello/rest/
+ */ var TRELLO_MAX_PAGE_LIMIT = 1000;
+/**
+ * Default reader that pulls `id` off the item. Works for most Trello resource types.
+ *
+ * @param item The page item whose id to read.
+ * @returns The item's id.
+ */ var defaultTrelloPageItemIdReader = function defaultTrelloPageItemIdReader(item) {
+    return item.id;
+};
+/**
+ * Reader that pulls the action id off a Trello action item.
+ *
+ * @param item The action page item whose id to read.
+ * @returns The item's action id.
+ */ var trelloActionIdReader = function trelloActionIdReader(item) {
+    return item.id;
+};
+/**
+ * Wraps a raw Trello collection fetch into a {@link TrelloPageResult}.
+ *
+ * @param input The page filter that was used.
+ * @param data The raw page items.
+ * @param idReader Function to read the id from the last item.
+ * @returns A page result with the data and a cursor for the next page.
+ * @__NO_SIDE_EFFECTS__
+ */ function buildTrelloPageResult(input, data, idReader) {
+    var _input_limit;
+    var limit = (_input_limit = input.limit) !== null && _input_limit !== void 0 ? _input_limit : data.length;
+    var hasMore = data.length === limit && data.length > 0;
+    var nextBefore = hasMore ? idReader(data[data.length - 1]) : undefined;
+    return {
+        data: data,
+        limit: limit,
+        nextBefore: nextBefore
+    };
+}
+/**
+ * Creates a FetchPageFactory using the input TrelloFetchPageFetchFunction.
+ *
+ * @param fetch Function that fetches a single page of results from the Trello API.
+ * @param defaults Optional default pagination configuration.
+ * @returns A configured FetchPageFactory that handles Trello's cursor-based pagination using `before`.
+ * @__NO_SIDE_EFFECTS__
+ */ function trelloFetchPageFactory(fetch$1, defaults) {
+    return fetch.fetchPageFactory(_object_spread_props(_object_spread({}, defaults), {
+        fetch: fetch$1,
+        readFetchPageResultInfo: function readFetchPageResultInfo(result) {
+            return {
+                nextPageCursor: result.nextBefore,
+                hasNext: Boolean(result.nextBefore)
+            };
+        },
+        buildInputForNextPage: function buildInputForNextPage(pageResult, input, options) {
+            var _options_maxItemsPerPage;
+            return _object_spread_props(_object_spread({}, input), {
+                before: pageResult.nextPageCursor,
+                limit: (_options_maxItemsPerPage = options.maxItemsPerPage) !== null && _options_maxItemsPerPage !== void 0 ? _options_maxItemsPerPage : input.limit
+            });
+        }
+    }));
+}
+
+exports.DEFAULT_TRELLO_API_RATE_LIMIT = DEFAULT_TRELLO_API_RATE_LIMIT;
+exports.DEFAULT_TRELLO_API_RATE_LIMIT_RESET_PERIOD = DEFAULT_TRELLO_API_RATE_LIMIT_RESET_PERIOD;
+exports.TRELLO_API_URL = TRELLO_API_URL;
+exports.TRELLO_MAX_PAGE_LIMIT = TRELLO_MAX_PAGE_LIMIT;
+exports.TrelloInvalidTokenError = TrelloInvalidTokenError;
+exports.TrelloServerError = TrelloServerError;
+exports.TrelloServerFetchResponseError = TrelloServerFetchResponseError;
+exports.TrelloTooManyRequestsError = TrelloTooManyRequestsError;
+exports.addCommentToCard = addCommentToCard;
+exports.addLabelToCard = addLabelToCard;
+exports.addMemberToCard = addMemberToCard;
+exports.buildTrelloPageResult = buildTrelloPageResult;
+exports.createBoard = createBoard;
+exports.createCard = createCard;
+exports.createList = createList;
+exports.createWebhook = createWebhook;
+exports.defaultTrelloPageItemIdReader = defaultTrelloPageItemIdReader;
+exports.deleteBoard = deleteBoard;
+exports.deleteCard = deleteCard;
+exports.deleteWebhook = deleteWebhook;
+exports.getBoard = getBoard;
+exports.getCard = getCard;
+exports.getList = getList;
+exports.getMe = getMe;
+exports.getMember = getMember;
+exports.getWebhook = getWebhook;
+exports.handleTrelloErrorFetch = handleTrelloErrorFetch;
+exports.listBoardCards = listBoardCards;
+exports.listBoardLabels = listBoardLabels;
+exports.listBoardLists = listBoardLists;
+exports.listBoardMembers = listBoardMembers;
+exports.listCardActions = listCardActions;
+exports.listCardsInList = listCardsInList;
+exports.listWebhooksForToken = listWebhooksForToken;
+exports.logTrelloErrorToConsole = logTrelloErrorToConsole;
+exports.logTrelloServerErrorFunction = logTrelloServerErrorFunction;
+exports.parseTrelloApiError = parseTrelloApiError;
+exports.trelloActionIdReader = trelloActionIdReader;
+exports.trelloFactory = trelloFactory;
+exports.trelloFetchPageFactory = trelloFetchPageFactory;
+exports.trelloRateLimitedFetchHandler = trelloRateLimitedFetchHandler;
+exports.updateBoard = updateBoard;
+exports.updateCard = updateCard;
+exports.updateList = updateList;
+exports.updateWebhook = updateWebhook;