@dereekb/calcom 13.4.0

package/index.cjs.js

@@ -0,0 +1,2202 @@
+'use strict';
+
+var fetch = require('@dereekb/util/fetch');
+var util = require('@dereekb/util');
+var makeError = require('make-error');
+
+function _assert_this_initialized$1(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep$5(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$5(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super$1(_this, derived, args) {
+    derived = _get_prototype_of$1(derived);
+    return _possible_constructor_return$1(_this, _is_native_reflect_construct$1() ? Reflect.construct(derived, args || [], _get_prototype_of$1(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$1(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$1(o) {
+    _get_prototype_of$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$1(o);
+}
+function _inherits$1(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$1(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _possible_constructor_return$1(self, call) {
+    if (call && (_type_of$1(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$1(self);
+}
+function _set_prototype_of$1(o, p) {
+    _set_prototype_of$1 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$1(o, p);
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$1() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$1 = function() {
+        return !!result;
+    })();
+}
+function _ts_generator$5(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
+        };
+    }
+}
+/**
+ * Cal.com Server Error
+ */ var CalcomServerError = /*#__PURE__*/ function(BaseError) {
+    _inherits$1(CalcomServerError, BaseError);
+    function CalcomServerError(error) {
+        _class_call_check$1(this, CalcomServerError);
+        var _this;
+        _this = _call_super$1(this, CalcomServerError, [
+            error.message
+        ]), _define_property$2(_this, "error", void 0);
+        _this.error = error;
+        return _this;
+    }
+    _create_class(CalcomServerError, [
+        {
+            key: "code",
+            get: function get() {
+                return this.error.code;
+            }
+        }
+    ]);
+    return CalcomServerError;
+}(makeError.BaseError);
+/**
+ * Cal.com Server Error that includes the FetchResponseError
+ */ var CalcomServerFetchResponseError = /*#__PURE__*/ function(CalcomServerError) {
+    _inherits$1(CalcomServerFetchResponseError, CalcomServerError);
+    function CalcomServerFetchResponseError(data, responseError) {
+        _class_call_check$1(this, CalcomServerFetchResponseError);
+        var _this;
+        _this = _call_super$1(this, CalcomServerFetchResponseError, [
+            data
+        ]), _define_property$2(_this, "data", void 0), _define_property$2(_this, "responseError", void 0);
+        _this.data = data;
+        _this.responseError = responseError;
+        return _this;
+    }
+    return CalcomServerFetchResponseError;
+}(CalcomServerError);
+/**
+ * Creates a logCalcomServerErrorFunction that logs the error to console.
+ *
+ * @param calcomApiNamePrefix Prefix to use when logging. I.E. CalcomError, etc.
+ * @returns
+ */ function logCalcomServerErrorFunction(calcomApiNamePrefix) {
+    return function(error) {
+        if (_instanceof(error, CalcomServerFetchResponseError)) {
+            console.log("".concat(calcomApiNamePrefix, "Error(").concat(error.responseError.response.status, "): "), {
+                error: error,
+                errorData: error.data
+            });
+        } else if (_instanceof(error, CalcomServerError)) {
+            console.log("".concat(calcomApiNamePrefix, "Error(code:").concat(error.code, "): "), {
+                error: error
+            });
+        } else {
+            console.log("".concat(calcomApiNamePrefix, "Error(name:").concat(error.name, "): "), {
+                error: error
+            });
+        }
+    };
+}
+/**
+ * Wraps a ConfiguredFetch to support handling errors returned by fetch.
+ */ function handleCalcomErrorFetchFactory(parseCalcomError, defaultLogError) {
+    return function(fetch$1) {
+        var logError = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : defaultLogError;
+        return function(x, y) {
+            return _async_to_generator$5(function() {
+                var e, error;
+                return _ts_generator$5(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()
+                            ]; // await to catch thrown errors
+                        case 2:
+                            e = _state.sent();
+                            if (!_instanceof(e, fetch.FetchResponseError)) return [
+                                3,
+                                4
+                            ];
+                            return [
+                                4,
+                                parseCalcomError(e)
+                            ];
+                        case 3:
+                            error = _state.sent();
+                            if (error) {
+                                logError(error); // log before throwing.
+                                throw error;
+                            }
+                            _state.label = 4;
+                        case 4:
+                            throw e;
+                        case 5:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        };
+    };
+}
+// MARK: Parsed Errors
+/**
+ * The status code that indicates too many requests have been made.
+ */ var CALCOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE = 429;
+var CALCOM_RATE_LIMIT_LIMIT_HEADER = 'X-RateLimit-Limit';
+var CALCOM_RATE_LIMIT_REMAINING_HEADER = 'X-RateLimit-Remaining';
+var CALCOM_RATE_LIMIT_RESET_HEADER = 'X-RateLimit-Reset';
+var DEFAULT_CALCOM_API_RATE_LIMIT = 100;
+var DEFAULT_CALCOM_API_RATE_LIMIT_RESET_PERIOD = 60 * util.MS_IN_SECOND;
+function calcomRateLimitHeaderDetails(headers) {
+    var limitHeader = headers.get(CALCOM_RATE_LIMIT_LIMIT_HEADER);
+    var remainingHeader = headers.get(CALCOM_RATE_LIMIT_REMAINING_HEADER);
+    var resetHeader = headers.get(CALCOM_RATE_LIMIT_RESET_HEADER);
+    var result = null;
+    if (limitHeader != null || remainingHeader != null || resetHeader != null) {
+        var limit = limitHeader ? Number(limitHeader) : undefined;
+        var remaining = remainingHeader ? Number(remainingHeader) : undefined;
+        var resetAt = resetHeader ? new Date(Number(resetHeader) * util.MS_IN_SECOND) : undefined;
+        result = {
+            limit: limit,
+            remaining: remaining,
+            resetAt: resetAt
+        };
+    }
+    return result;
+}
+var CalcomTooManyRequestsError = /*#__PURE__*/ function(CalcomServerFetchResponseError) {
+    _inherits$1(CalcomTooManyRequestsError, CalcomServerFetchResponseError);
+    function CalcomTooManyRequestsError() {
+        _class_call_check$1(this, CalcomTooManyRequestsError);
+        return _call_super$1(this, CalcomTooManyRequestsError, arguments);
+    }
+    _create_class(CalcomTooManyRequestsError, [
+        {
+            key: "headerDetails",
+            get: function get() {
+                return calcomRateLimitHeaderDetails(this.responseError.response.headers);
+            }
+        }
+    ]);
+    return CalcomTooManyRequestsError;
+}(CalcomServerFetchResponseError);
+/**
+ * Function that parses/transforms a CalcomServerErrorData into a general CalcomServerError or other known error type.
+ */ function parseCalcomServerErrorData(calcomServerError, responseError) {
+    var result;
+    if (responseError.response.status === CALCOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE) {
+        result = new CalcomTooManyRequestsError(calcomServerError, responseError);
+        console.warn('CalcomTooManyRequestsError', {
+            result: result,
+            responseError: responseError,
+            headerDetails: result.headerDetails
+        });
+    } else if (calcomServerError) {
+        switch(calcomServerError.code){
+            default:
+                result = new CalcomServerFetchResponseError(calcomServerError, responseError);
+                break;
+        }
+    }
+    return result;
+}
+
+function asyncGeneratorStep$4(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$4(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$4(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
+        };
+    }
+}
+// MARK: Parser
+var logCalcomErrorToConsole = logCalcomServerErrorFunction('Calcom');
+function parseCalcomApiError(responseError) {
+    return _async_to_generator$4(function() {
+        var data, result;
+        return _ts_generator$4(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        responseError.response.json().catch(function(_x) {
+                            return undefined;
+                        })
+                    ];
+                case 1:
+                    data = _state.sent();
+                    if (data) {
+                        result = parseCalcomApiServerErrorResponseData(data, responseError);
+                    }
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+function parseCalcomApiServerErrorResponseData(calcomServerError, responseError) {
+    var result;
+    if (calcomServerError) {
+        switch(calcomServerError.code){
+            default:
+                result = parseCalcomServerErrorData(calcomServerError, responseError);
+                break;
+        }
+    }
+    return result;
+}
+var handleCalcomErrorFetch = handleCalcomErrorFetchFactory(parseCalcomApiError, logCalcomErrorToConsole);
+
+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 _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 _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 _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
+        };
+    }
+}
+/**
+ * Error in the following cases:
+ * - the refresh token string is invalid
+ */ var CALCOM_OAUTH_INVALID_GRANT_ERROR_CODE = 'invalid_grant';
+/**
+ * Thrown if the call to the Cal.com API creating an access token using a refresh token fails.
+ */ var CalcomOAuthAccessTokenError = /*#__PURE__*/ function(FetchRequestFactoryError) {
+    _inherits(CalcomOAuthAccessTokenError, FetchRequestFactoryError);
+    function CalcomOAuthAccessTokenError(errorCode) {
+        _class_call_check(this, CalcomOAuthAccessTokenError);
+        var _this;
+        _this = _call_super(this, CalcomOAuthAccessTokenError, [
+            "CalcomOAuthAccessTokenError: ".concat(errorCode)
+        ]), _define_property$1(_this, "errorCode", void 0);
+        _this.errorCode = errorCode;
+        return _this;
+    }
+    return CalcomOAuthAccessTokenError;
+}(fetch.FetchRequestFactoryError);
+/**
+ * Thrown if a valid CalcomAccessToken cannot be retrieved successfully.
+ */ var CalcomOAuthAuthFailureError = /*#__PURE__*/ function(FetchRequestFactoryError) {
+    _inherits(CalcomOAuthAuthFailureError, FetchRequestFactoryError);
+    function CalcomOAuthAuthFailureError(reason) {
+        _class_call_check(this, CalcomOAuthAuthFailureError);
+        var _this;
+        _this = _call_super(this, CalcomOAuthAuthFailureError, [
+            "Failed to retrieve proper authentication for the API call. Reason: ".concat(reason)
+        ]), _define_property$1(_this, "reason", void 0);
+        _this.reason = reason;
+        return _this;
+    }
+    return CalcomOAuthAuthFailureError;
+}(fetch.FetchRequestFactoryError);
+var logCalcomOAuthErrorToConsole = logCalcomServerErrorFunction('CalcomOAuth');
+function parseCalcomOAuthError(responseError) {
+    return _async_to_generator$3(function() {
+        var data, result;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        responseError.response.json().catch(function(_x) {
+                            return undefined;
+                        })
+                    ];
+                case 1:
+                    data = _state.sent();
+                    if (data) {
+                        result = parseCalcomOAuthServerErrorResponseData(data, responseError);
+                    }
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+function parseCalcomOAuthServerErrorResponseData(calcomServerError, responseError) {
+    var result;
+    if (calcomServerError) {
+        var potentialErrorStringCode = calcomServerError.error;
+        var errorCode = potentialErrorStringCode !== null && potentialErrorStringCode !== void 0 ? potentialErrorStringCode : calcomServerError.code;
+        switch(errorCode){
+            case CALCOM_OAUTH_INVALID_GRANT_ERROR_CODE:
+                result = new CalcomOAuthAccessTokenError(errorCode);
+                break;
+            default:
+                result = parseCalcomServerErrorData(calcomServerError, responseError);
+                break;
+        }
+    }
+    return result;
+}
+var handleCalcomOAuthErrorFetch = handleCalcomErrorFetchFactory(parseCalcomOAuthError, logCalcomOAuthErrorToConsole);
+
+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 _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
+        };
+    }
+}
+/**
+ * Generates a new CalcomAccessTokenStringFactory.
+ */ function calcomAccessTokenStringFactory(calcomAccessTokenFactory) {
+    return function() {
+        return _async_to_generator$2(function() {
+            var token;
+            return _ts_generator$2(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            calcomAccessTokenFactory()
+                        ];
+                    case 1:
+                        token = _state.sent();
+                        if (!(token === null || token === void 0 ? void 0 : token.accessToken)) {
+                            throw new CalcomOAuthAuthFailureError();
+                        }
+                        return [
+                            2,
+                            token.accessToken
+                        ];
+                }
+            });
+        })();
+    };
+}
+
+var DEFAULT_CALCOM_RATE_LIMITED_TOO_MANY_REQUESTS_LOG_FUNCTION = function DEFAULT_CALCOM_RATE_LIMITED_TOO_MANY_REQUESTS_LOG_FUNCTION(headers) {
+    console.warn("calcomRateLimitedFetchHandler(): Too many requests made. The limit is ".concat(headers.limit, " requests per reset period. ResetAt is set for ").concat(headers.resetAt, "."));
+};
+function calcomRateLimitedFetchHandler(config) {
+    var _ref, _ref1, _ref2;
+    var onTooManyRequests = (config === null || config === void 0 ? void 0 : config.onTooManyRequests) !== false ? (_ref = config === null || config === void 0 ? void 0 : config.onTooManyRequests) !== null && _ref !== void 0 ? _ref : DEFAULT_CALCOM_RATE_LIMITED_TOO_MANY_REQUESTS_LOG_FUNCTION : undefined;
+    var defaultLimit = (_ref1 = config === null || config === void 0 ? void 0 : config.maxRateLimit) !== null && _ref1 !== void 0 ? _ref1 : DEFAULT_CALCOM_API_RATE_LIMIT;
+    var defaultResetPeriod = (_ref2 = config === null || config === void 0 ? void 0 : config.resetPeriod) !== null && _ref2 !== void 0 ? _ref2 : DEFAULT_CALCOM_API_RATE_LIMIT_RESET_PERIOD;
+    function configForLimit(limit, resetAt) {
+        return {
+            limit: defaultLimit,
+            startLimitAt: 10,
+            cooldownRate: 1.2,
+            exponentRate: 1.08,
+            maxWaitTime: util.MS_IN_SECOND * 10,
+            resetPeriod: defaultResetPeriod,
+            resetAt: resetAt
+        };
+    }
+    var defaultConfig = configForLimit();
+    var rateLimiter = util.resetPeriodPromiseRateLimiter(defaultConfig);
+    return fetch.rateLimitedFetchHandler({
+        rateLimiter: rateLimiter,
+        updateWithResponse: function updateWithResponse(response, fetchResponseError) {
+            var hasRemainingHeader = response.headers.has(CALCOM_RATE_LIMIT_REMAINING_HEADER);
+            var shouldRetry = false;
+            if (hasRemainingHeader) {
+                var headerDetails = calcomRateLimitHeaderDetails(response.headers);
+                if (headerDetails) {
+                    var limit = headerDetails.limit, remaining = headerDetails.remaining, resetAt = headerDetails.resetAt;
+                    if (response.status === CALCOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE) {
+                        shouldRetry = true;
+                        try {
+                            onTooManyRequests === null || onTooManyRequests === void 0 ? void 0 : onTooManyRequests(headerDetails, response, fetchResponseError);
+                        } catch (_) {
+                        // ignore logging errors
+                        }
+                    }
+                    if (limit != null && resetAt != null && remaining != null) {
+                        if (limit !== defaultLimit) {
+                            var newConfig = configForLimit(limit, resetAt);
+                            rateLimiter.setConfig(newConfig, false);
+                        }
+                        rateLimiter.setRemainingLimit(remaining);
+                        rateLimiter.setNextResetAt(resetAt);
+                    }
+                }
+            } else if (response.status === CALCOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE) {
+                shouldRetry = true;
+                try {
+                    var headerDetails1 = {};
+                    onTooManyRequests === null || onTooManyRequests === void 0 ? void 0 : onTooManyRequests(headerDetails1, response, fetchResponseError);
+                } catch (_) {
+                // ignore logging errors
+                }
+            }
+            return shouldRetry;
+        }
+    });
+}
+
+/**
+ * The Cal.com API URL.
+ */ var CALCOM_API_URL = 'https://api.cal.com/v2';
+
+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 _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
+        };
+    }
+}
+function calcomFactory(factoryConfig) {
+    var oauthContext = factoryConfig.oauthContext;
+    var serverAccessTokenStringFactory = calcomAccessTokenStringFactory(oauthContext.loadAccessToken);
+    var fetchHandler = calcomRateLimitedFetchHandler(factoryConfig.rateLimiterConfig);
+    var logCalcomServerErrorFunction = factoryConfig.logCalcomServerErrorFunction, _factoryConfig_fetchFactory = factoryConfig.fetchFactory, fetchFactory = _factoryConfig_fetchFactory === void 0 ? function(input) {
+        return fetch.fetchApiFetchService.makeFetch({
+            baseUrl: CALCOM_API_URL,
+            baseRequest: function baseRequest() {
+                return _async_to_generator$1(function() {
+                    var _tmp, _tmp1, _, _1;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _tmp = {};
+                                _tmp1 = {
+                                    'Content-Type': 'application/json'
+                                };
+                                _1 = (_ = "Bearer ").concat;
+                                return [
+                                    4,
+                                    input.calcomAccessTokenStringFactory()
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    (_tmp.headers = (_tmp1.Authorization = _1.apply(_, [
+                                        _state.sent()
+                                    ]), _tmp1), _tmp)
+                                ];
+                        }
+                    });
+                })();
+            },
+            fetchHandler: fetchHandler,
+            timeout: 20 * 1000,
+            requireOkResponse: true,
+            useTimeout: true // use timeout
+        });
+    } : _factoryConfig_fetchFactory;
+    return function(config) {
+        var baseFetch = fetchFactory({
+            calcomAccessTokenStringFactory: serverAccessTokenStringFactory
+        });
+        var serverFetch = handleCalcomErrorFetch(baseFetch, logCalcomServerErrorFunction);
+        var serverFetchJson = fetch.fetchJsonFunction(serverFetch, {
+            handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
+        });
+        // MARK: Make Public Context
+        var makePublicContext = function makePublicContext() {
+            var publicFetch = fetch.fetchApiFetchService.makeFetch({
+                baseUrl: CALCOM_API_URL,
+                baseRequest: {
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                },
+                fetchHandler: fetchHandler,
+                timeout: 20 * 1000,
+                requireOkResponse: true,
+                useTimeout: true
+            });
+            var publicHandledFetch = handleCalcomErrorFetch(publicFetch, logCalcomServerErrorFunction);
+            var publicFetchJson = fetch.fetchJsonFunction(publicHandledFetch, {
+                handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
+            });
+            return {
+                fetch: publicHandledFetch,
+                fetchJson: publicFetchJson
+            };
+        };
+        // MARK: Make User Context
+        var makeUserContext = function makeUserContext(input) {
+            var userAccessTokenFactory = oauthContext.makeUserAccessTokenFactory({
+                refreshToken: input.refreshToken,
+                userAccessTokenCache: input.accessTokenCache
+            });
+            var userAccessTokenStringFactory = calcomAccessTokenStringFactory(userAccessTokenFactory);
+            var userBaseFetch = fetchFactory({
+                calcomAccessTokenStringFactory: userAccessTokenStringFactory
+            });
+            var userFetch = handleCalcomErrorFetch(userBaseFetch, logCalcomServerErrorFunction);
+            var userFetchJson = fetch.fetchJsonFunction(userFetch, {
+                handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
+            });
+            var result = {
+                calcomServerContext: calcomContext,
+                type: 'user',
+                fetch: userFetch,
+                fetchJson: userFetchJson,
+                userFetch: userFetch,
+                userFetchJson: userFetchJson,
+                calcomRateLimiter: fetchHandler._rateLimiter
+            };
+            return result;
+        };
+        var calcomContext = {
+            type: 'server',
+            fetch: serverFetch,
+            fetchJson: serverFetchJson,
+            serverFetch: serverFetch,
+            serverFetchJson: serverFetchJson,
+            makeUserContext: makeUserContext,
+            makePublicContext: makePublicContext,
+            config: config,
+            calcomRateLimiter: fetchHandler._rateLimiter
+        };
+        var calcom = {
+            calcomServerContext: calcomContext
+        };
+        return calcom;
+    };
+}
+
+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;
+}
+/**
+ * Cal.com API version header constants.
+ *
+ * Each endpoint group requires a specific cal-api-version header value.
+ */ var CALCOM_API_VERSION_SCHEDULES = '2024-06-11';
+var CALCOM_API_VERSION_SLOTS = '2024-09-04';
+var CALCOM_API_VERSION_BOOKINGS = '2024-08-13';
+var CALCOM_API_VERSION_EVENT_TYPES = '2024-06-14';
+var CALCOM_API_VERSION_CALENDARS = '2024-06-11';
+var CALCOM_API_VERSION_ME = '2024-08-13';
+var CALCOM_API_VERSION_HEADER = 'cal-api-version';
+/**
+ * Returns a headers object with the cal-api-version header set.
+ */ function calcomApiVersionHeaders(version) {
+    return _define_property({}, CALCOM_API_VERSION_HEADER, version);
+}
+
+/**
+ * Retrieves the profile of the currently authenticated Cal.com user.
+ *
+ * @see https://cal.com/docs/api-reference/v2/me
+ *
+ * @example
+ * ```ts
+ * const response = await getMe(context)();
+ * console.log(response.data.email);
+ * ```
+ */ function getMe(context) {
+    return function() {
+        return context.fetchJson('/me', {
+            method: 'GET',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_ME)
+        });
+    };
+}
+
+/**
+ * Retrieves all schedules for the authenticated user, including availability rules and overrides.
+ *
+ * @see https://cal.com/docs/api-reference/v2/schedules/get-all-schedules
+ *
+ * @example
+ * ```ts
+ * const response = await getSchedules(context)();
+ * response.data.forEach(schedule => console.log(schedule.name, schedule.timeZone));
+ * ```
+ */ function getSchedules(context) {
+    return function() {
+        return context.fetchJson('/schedules', {
+            method: 'GET',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_SCHEDULES)
+        });
+    };
+}
+
+/**
+ * Queries available booking slots for a given event type within a date range.
+ * This endpoint is public and does not require authentication.
+ *
+ * Identify the event type by `eventTypeId`, or by `eventTypeSlug` + `username`/`teamSlug`.
+ *
+ * @see https://cal.com/docs/api-reference/v2/slots/get-available-time-slots-for-an-event-type
+ *
+ * @example
+ * ```ts
+ * const response = await getAvailableSlots(context)({
+ *   start: '2026-03-17T00:00:00.000Z',
+ *   end: '2026-03-24T00:00:00.000Z',
+ *   eventTypeId: 12345
+ * });
+ *
+ * for (const [date, slots] of Object.entries(response.data.slots)) {
+ *   console.log(date, slots.map(s => s.time));
+ * }
+ * ```
+ */ function getAvailableSlots(context) {
+    return function(input) {
+        var params = fetch.makeUrlSearchParams(input);
+        return context.fetchJson("/slots?".concat(params), {
+            method: 'GET',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_SLOTS)
+        });
+    };
+}
+
+/**
+ * Creates a new booking for the specified event type. The `attendee` represents the person
+ * booking (the client), not the host. This endpoint can be called without authentication.
+ *
+ * @see https://cal.com/docs/api-reference/v2/bookings/create-a-booking
+ *
+ * @example
+ * ```ts
+ * const response = await createBooking(context)({
+ *   start: '2026-03-20T14:00:00.000Z',
+ *   eventTypeId: 12345,
+ *   attendee: { name: 'Jane Doe', email: 'jane@example.com', timeZone: 'America/New_York' }
+ * });
+ * console.log(response.data.uid);
+ * ```
+ */ function createBooking(context) {
+    return function(input) {
+        return context.fetchJson('/bookings', {
+            method: 'POST',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_BOOKINGS),
+            body: JSON.stringify(input)
+        });
+    };
+}
+/**
+ * Retrieves a booking by its unique UID.
+ *
+ * @see https://cal.com/docs/api-reference/v2/bookings/get-a-booking
+ *
+ * @example
+ * ```ts
+ * const response = await getBooking(context)('abc-123-uid');
+ * console.log(response.data.title, response.data.status);
+ * ```
+ */ function getBooking(context) {
+    return function(uid) {
+        return context.fetchJson("/bookings/".concat(uid), {
+            method: 'GET',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_BOOKINGS)
+        });
+    };
+}
+/**
+ * Cancels a booking by its unique UID, with an optional cancellation reason.
+ *
+ * @see https://cal.com/docs/api-reference/v2/bookings/cancel-a-booking
+ *
+ * @example
+ * ```ts
+ * await cancelBooking(context)({ uid: 'abc-123-uid', cancellationReason: 'Schedule conflict' });
+ * ```
+ */ function cancelBooking(context) {
+    return function(input) {
+        var body = {};
+        if (input.cancellationReason) {
+            body['cancellationReason'] = input.cancellationReason;
+        }
+        return context.fetchJson("/bookings/".concat(input.uid, "/cancel"), {
+            method: 'POST',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_BOOKINGS),
+            body: JSON.stringify(body)
+        });
+    };
+}
+
+/**
+ * Retrieves all event types for the authenticated user.
+ *
+ * @see https://cal.com/docs/api-reference/v2/event-types/get-all-event-types
+ *
+ * @example
+ * ```ts
+ * const response = await getEventTypes(context)();
+ * response.data.forEach(et => console.log(et.title, et.slug, et.lengthInMinutes));
+ * ```
+ */ function getEventTypes(context) {
+    return function() {
+        return context.fetchJson('/event-types', {
+            method: 'GET',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_EVENT_TYPES)
+        });
+    };
+}
+/**
+ * Creates a new event type for the authenticated user.
+ *
+ * @see https://cal.com/docs/api-reference/v2/event-types/create-an-event-type
+ *
+ * @example
+ * ```ts
+ * const response = await createEventType(context)({
+ *   title: 'Mentoring Session',
+ *   slug: 'mentoring-session',
+ *   lengthInMinutes: 30
+ * });
+ * console.log(response.data.id);
+ * ```
+ */ function createEventType(context) {
+    return function(input) {
+        return context.fetchJson('/event-types', {
+            method: 'POST',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_EVENT_TYPES),
+            body: JSON.stringify(input)
+        });
+    };
+}
+/**
+ * Updates an existing event type by ID.
+ *
+ * @see https://cal.com/docs/api-reference/v2/event-types/update-an-event-type
+ *
+ * @example
+ * ```ts
+ * await updateEventType(context)(12345, { title: 'Updated Session Title' });
+ * ```
+ */ function updateEventType(context) {
+    return function(eventTypeId, input) {
+        return context.fetchJson("/event-types/".concat(eventTypeId), {
+            method: 'PATCH',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_EVENT_TYPES),
+            body: JSON.stringify(input)
+        });
+    };
+}
+/**
+ * Deletes an event type by ID.
+ *
+ * @see https://cal.com/docs/api-reference/v2/event-types/delete-an-event-type
+ *
+ * @example
+ * ```ts
+ * await deleteEventType(context)(12345);
+ * ```
+ */ function deleteEventType(context) {
+    return function(eventTypeId) {
+        return context.fetchJson("/event-types/".concat(eventTypeId), {
+            method: 'DELETE',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_EVENT_TYPES)
+        });
+    };
+}
+
+/**
+ * Retrieves all connected calendars and the destination calendar for the authenticated user.
+ *
+ * @see https://cal.com/docs/api-reference/v2/calendars/get-all-calendars
+ *
+ * @example
+ * ```ts
+ * const response = await getCalendars(context)();
+ * response.data.connectedCalendars.forEach(cc => console.log(cc.integration));
+ * ```
+ */ function getCalendars(context) {
+    return function() {
+        return context.fetchJson('/calendars', {
+            method: 'GET',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_CALENDARS)
+        });
+    };
+}
+/**
+ * Retrieves busy time ranges across the user's connected calendars for a given date range.
+ *
+ * @see https://cal.com/docs/api-reference/v2/calendars/get-busy-times
+ *
+ * @example
+ * ```ts
+ * const response = await getBusyTimes(context)({
+ *   dateFrom: '2026-03-17',
+ *   dateTo: '2026-03-24'
+ * });
+ * response.data.forEach(bt => console.log(bt.start, bt.end));
+ * ```
+ */ function getBusyTimes(context) {
+    return function(input) {
+        var _input_calendarsToLoad;
+        var params = fetch.makeUrlSearchParams({
+            dateFrom: input.dateFrom,
+            dateTo: input.dateTo,
+            calendarsToLoad: (_input_calendarsToLoad = input.calendarsToLoad) === null || _input_calendarsToLoad === void 0 ? void 0 : _input_calendarsToLoad.join(',')
+        });
+        return context.fetchJson("/calendars/busy-times?".concat(params), {
+            method: 'GET',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_CALENDARS)
+        });
+    };
+}
+
+/**
+ * Creates a webhook subscription for the authenticated user. Webhooks notify your app
+ * when specified events occur (e.g., bookings created, cancelled, rescheduled).
+ *
+ * @see https://cal.com/docs/api-reference/v2/webhooks/create-a-webhook
+ *
+ * @example
+ * ```ts
+ * const response = await createWebhook(context)({
+ *   subscriberUrl: 'https://example.com/webhook/calcom',
+ *   triggers: ['BOOKING_CREATED', 'BOOKING_CANCELLED'],
+ *   active: true
+ * });
+ * console.log(response.data.id);
+ * ```
+ */ function createWebhook(context) {
+    return function(input) {
+        return context.fetchJson('/webhooks', {
+            method: 'POST',
+            body: JSON.stringify(input)
+        });
+    };
+}
+/**
+ * Retrieves all webhooks for the authenticated user.
+ *
+ * @see https://cal.com/docs/api-reference/v2/webhooks/get-all-webhooks
+ *
+ * @example
+ * ```ts
+ * const response = await getWebhooks(context)();
+ * response.data.forEach(wh => console.log(wh.subscriberUrl, wh.triggers));
+ * ```
+ */ function getWebhooks(context) {
+    return function() {
+        return context.fetchJson('/webhooks', {
+            method: 'GET'
+        });
+    };
+}
+/**
+ * Retrieves a specific webhook by ID.
+ *
+ * @see https://cal.com/docs/api-reference/v2/webhooks/get-a-webhook
+ *
+ * @example
+ * ```ts
+ * const response = await getWebhook(context)(42);
+ * console.log(response.data.subscriberUrl);
+ * ```
+ */ function getWebhook(context) {
+    return function(webhookId) {
+        return context.fetchJson("/webhooks/".concat(webhookId), {
+            method: 'GET'
+        });
+    };
+}
+/**
+ * Updates an existing webhook by ID.
+ *
+ * @see https://cal.com/docs/api-reference/v2/webhooks/update-a-webhook
+ *
+ * @example
+ * ```ts
+ * await updateWebhook(context)(42, { active: false });
+ * ```
+ */ function updateWebhook(context) {
+    return function(webhookId, input) {
+        return context.fetchJson("/webhooks/".concat(webhookId), {
+            method: 'PATCH',
+            body: JSON.stringify(input)
+        });
+    };
+}
+/**
+ * Deletes a webhook by ID.
+ *
+ * @see https://cal.com/docs/api-reference/v2/webhooks/delete-a-webhook
+ *
+ * @example
+ * ```ts
+ * await deleteWebhook(context)(42);
+ * ```
+ */ function deleteWebhook(context) {
+    return function(webhookId) {
+        return context.fetchJson("/webhooks/".concat(webhookId), {
+            method: 'DELETE'
+        });
+    };
+}
+
+/**
+ * Refreshes an access token using a refresh token. Cal.com rotates refresh tokens
+ * on every use, so the new `refresh_token` from the response must be persisted.
+ *
+ * Cal.com uses JSON body (not Basic Auth) for token requests.
+ *
+ * @see https://cal.com/docs/api-reference/v2/oauth/refresh-an-existing-access-token
+ *
+ * @example
+ * ```ts
+ * const response = await refreshAccessToken(context)({ refreshToken: 'existing-refresh-token' });
+ * console.log(response.access_token, response.refresh_token);
+ * ```
+ */ function refreshAccessToken(context) {
+    return function(input) {
+        var _ref;
+        var refreshToken = (_ref = input === null || input === void 0 ? void 0 : input.refreshToken) !== null && _ref !== void 0 ? _ref : context.config.refreshToken;
+        var fetchJsonInput = {
+            method: 'POST',
+            body: JSON.stringify({
+                grant_type: 'refresh_token',
+                client_id: context.config.clientId,
+                client_secret: context.config.clientSecret,
+                refresh_token: refreshToken
+            })
+        };
+        return context.fetchJson('/oauth/token', fetchJsonInput);
+    };
+}
+/**
+ * Exchanges an OAuth authorization code for access and refresh tokens.
+ * Used during the initial OAuth flow when a user authorizes your app.
+ *
+ * Cal.com uses JSON body (not Basic Auth) for token requests.
+ *
+ * @see https://cal.com/docs/api-reference/v2/oauth/exchange-an-authorization-code-for-access-tokens
+ *
+ * @example
+ * ```ts
+ * const response = await exchangeAuthorizationCode(context)({
+ *   code: 'auth-code-from-redirect',
+ *   redirectUri: 'https://example.com/callback'
+ * });
+ * console.log(response.access_token, response.refresh_token);
+ * ```
+ */ function exchangeAuthorizationCode(context) {
+    return function(input) {
+        var fetchJsonInput = {
+            method: 'POST',
+            body: JSON.stringify({
+                grant_type: 'authorization_code',
+                client_id: context.config.clientId,
+                client_secret: context.config.clientSecret,
+                code: input.code,
+                redirect_uri: input.redirectUri
+            })
+        };
+        return context.fetchJson('/oauth/token', fetchJsonInput);
+    };
+}
+
+/**
+ * The Cal.com OAuth token endpoint URL.
+ */ var CALCOM_OAUTH_TOKEN_URL = 'https://api.cal.com/v2/oauth/token';
+/**
+ * The Cal.com OAuth authorize URL.
+ */ var CALCOM_OAUTH_AUTHORIZE_URL = 'https://app.cal.com/auth/oauth2/authorize';
+
+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 _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
+        };
+    }
+}
+function calcomOAuthFactory(factoryConfig) {
+    var fetchHandler = calcomRateLimitedFetchHandler();
+    var logCalcomServerErrorFunction = factoryConfig.logCalcomServerErrorFunction, _factoryConfig_fetchFactory = factoryConfig.fetchFactory, fetchFactory = _factoryConfig_fetchFactory === void 0 ? function(_) {
+        return fetch.fetchApiFetchService.makeFetch({
+            baseUrl: CALCOM_OAUTH_TOKEN_URL,
+            baseRequest: {
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            },
+            fetchHandler: fetchHandler,
+            timeout: 20 * 1000,
+            requireOkResponse: true,
+            useTimeout: true // use timeout
+        });
+    } : _factoryConfig_fetchFactory;
+    return function(config) {
+        var accessTokenFromTokenResponse = function accessTokenFromTokenResponse(result) {
+            var createdAt = new Date().getTime();
+            var access_token = result.access_token, refresh_token = result.refresh_token, scope = result.scope, expires_in = result.expires_in;
+            // Store the new refresh token for next use
+            latestRefreshToken = refresh_token;
+            var accessToken = {
+                accessToken: access_token,
+                refreshToken: refresh_token,
+                expiresIn: expires_in,
+                expiresAt: new Date(createdAt + expires_in * util.MS_IN_SECOND),
+                scope: scope !== null && scope !== void 0 ? scope : ''
+            };
+            return accessToken;
+        };
+        var useApiKey = !!config.apiKey;
+        if (!useApiKey) {
+            if (!config.clientId) {
+                throw new Error('CalcomOAuthConfig missing clientId. Provide clientId+clientSecret for OAuth or apiKey for API key auth.');
+            } else if (!config.clientSecret) {
+                throw new Error('CalcomOAuthConfig missing clientSecret.');
+            }
+        }
+        var baseFetch = fetchFactory();
+        var fetch$1 = handleCalcomOAuthErrorFetch(baseFetch, logCalcomServerErrorFunction);
+        var fetchJson = fetch.fetchJsonFunction(fetch$1, {
+            handleFetchJsonParseErrorFunction: fetch.returnNullHandleFetchJsonParseErrorFunction
+        });
+        // MARK: API Key Auth (static token, no refresh)
+        if (useApiKey) {
+            var apiKeyToken = {
+                accessToken: config.apiKey,
+                refreshToken: '',
+                expiresIn: Number.MAX_SAFE_INTEGER,
+                expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365 * 100),
+                scope: ''
+            };
+            var loadAccessToken = function loadAccessToken() {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            apiKeyToken
+                        ];
+                    });
+                })();
+            };
+            var makeUserAccessTokenFactory = function makeUserAccessTokenFactory() {
+                throw new Error('makeUserAccessTokenFactory is not available when using API key auth. Use OAuth for per-user contexts.');
+            };
+            var oauthContext = {
+                fetch: fetch$1,
+                fetchJson: fetchJson,
+                loadAccessToken: loadAccessToken,
+                makeUserAccessTokenFactory: makeUserAccessTokenFactory,
+                config: config
+            };
+            return {
+                oauthContext: oauthContext
+            };
+        }
+        // MARK: OAuth Auth (refresh token flow)
+        /**
+         * Tracks the latest refresh token since Cal.com rotates them.
+         */ var latestRefreshToken = config.refreshToken;
+        var tokenRefresher = function tokenRefresher() {
+            return _async_to_generator(function() {
+                var accessToken;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                refreshAccessToken(oauthContext1)({
+                                    refreshToken: latestRefreshToken !== null && latestRefreshToken !== void 0 ? latestRefreshToken : undefined
+                                })
+                            ];
+                        case 1:
+                            accessToken = _state.sent();
+                            return [
+                                2,
+                                accessTokenFromTokenResponse(accessToken)
+                            ];
+                    }
+                });
+            })();
+        };
+        var loadAccessToken1 = calcomOAuthAccessTokenFactory({
+            tokenRefresher: tokenRefresher,
+            accessTokenCache: config.accessTokenCache
+        });
+        // User Access Token
+        var makeUserAccessTokenFactory1 = function makeUserAccessTokenFactory(input) {
+            var userLatestRefreshToken = input.refreshToken;
+            var userTokenRefresher = function userTokenRefresher() {
+                return _async_to_generator(function() {
+                    var tokenResponse, token;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    refreshAccessToken(oauthContext1)({
+                                        refreshToken: userLatestRefreshToken
+                                    })
+                                ];
+                            case 1:
+                                tokenResponse = _state.sent();
+                                token = accessTokenFromTokenResponse(tokenResponse);
+                                // Track the rotated refresh token for this user
+                                userLatestRefreshToken = token.refreshToken;
+                                return [
+                                    2,
+                                    token
+                                ];
+                        }
+                    });
+                })();
+            };
+            return calcomOAuthAccessTokenFactory({
+                tokenRefresher: userTokenRefresher,
+                accessTokenCache: input.userAccessTokenCache
+            });
+        };
+        var oauthContext1 = {
+            fetch: fetch$1,
+            fetchJson: fetchJson,
+            loadAccessToken: loadAccessToken1,
+            makeUserAccessTokenFactory: makeUserAccessTokenFactory1,
+            config: config
+        };
+        var calcomOAuth = {
+            oauthContext: oauthContext1
+        };
+        return calcomOAuth;
+    };
+}
+/**
+ * Creates a CalcomAccessTokenFactory with multi-tier caching.
+ */ function calcomOAuthAccessTokenFactory(config) {
+    var tokenRefresher = config.tokenRefresher, accessTokenCache = config.accessTokenCache, inputTokenExpirationBuffer = config.tokenExpirationBuffer;
+    var tokenExpirationBuffer = inputTokenExpirationBuffer !== null && inputTokenExpirationBuffer !== void 0 ? inputTokenExpirationBuffer : util.MS_IN_MINUTE;
+    /**
+     * Caches the token internally here until it expires.
+     */ var currentToken = null;
+    return function() {
+        return _async_to_generator(function() {
+            var cachedToken, isExpired, e;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!!currentToken) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            accessTokenCache === null || accessTokenCache === void 0 ? void 0 : accessTokenCache.loadCachedToken()
+                        ];
+                    case 1:
+                        cachedToken = _state.sent();
+                        if (cachedToken) {
+                            currentToken = cachedToken;
+                        }
+                        _state.label = 2;
+                    case 2:
+                        // check expiration
+                        if (currentToken != null) {
+                            isExpired = new Date().getTime() + tokenExpirationBuffer >= currentToken.expiresAt.getTime();
+                            if (isExpired) {
+                                currentToken = null;
+                            }
+                        }
+                        if (!!currentToken) return [
+                            3,
+                            10
+                        ];
+                        _state.label = 3;
+                    case 3:
+                        _state.trys.push([
+                            3,
+                            5,
+                            ,
+                            6
+                        ]);
+                        return [
+                            4,
+                            tokenRefresher()
+                        ];
+                    case 4:
+                        currentToken = _state.sent();
+                        return [
+                            3,
+                            6
+                        ];
+                    case 5:
+                        e = _state.sent();
+                        console.error("calcomOAuthAccessTokenFactory(): Failed retrieving new token from tokenRefresher: ", e);
+                        throw new CalcomOAuthAuthFailureError('Token Refresh Failed');
+                    case 6:
+                        if (!currentToken) return [
+                            3,
+                            10
+                        ];
+                        _state.label = 7;
+                    case 7:
+                        _state.trys.push([
+                            7,
+                            9,
+                            ,
+                            10
+                        ]);
+                        return [
+                            4,
+                            accessTokenCache === null || accessTokenCache === void 0 ? void 0 : accessTokenCache.updateCachedToken(currentToken)
+                        ];
+                    case 8:
+                        _state.sent();
+                        return [
+                            3,
+                            10
+                        ];
+                    case 9:
+                        _state.sent();
+                        return [
+                            3,
+                            10
+                        ];
+                    case 10:
+                        return [
+                            2,
+                            currentToken
+                        ];
+                }
+            });
+        })();
+    };
+}
+
+exports.CALCOM_API_URL = CALCOM_API_URL;
+exports.CALCOM_API_VERSION_BOOKINGS = CALCOM_API_VERSION_BOOKINGS;
+exports.CALCOM_API_VERSION_CALENDARS = CALCOM_API_VERSION_CALENDARS;
+exports.CALCOM_API_VERSION_EVENT_TYPES = CALCOM_API_VERSION_EVENT_TYPES;
+exports.CALCOM_API_VERSION_HEADER = CALCOM_API_VERSION_HEADER;
+exports.CALCOM_API_VERSION_ME = CALCOM_API_VERSION_ME;
+exports.CALCOM_API_VERSION_SCHEDULES = CALCOM_API_VERSION_SCHEDULES;
+exports.CALCOM_API_VERSION_SLOTS = CALCOM_API_VERSION_SLOTS;
+exports.CALCOM_OAUTH_AUTHORIZE_URL = CALCOM_OAUTH_AUTHORIZE_URL;
+exports.CALCOM_OAUTH_INVALID_GRANT_ERROR_CODE = CALCOM_OAUTH_INVALID_GRANT_ERROR_CODE;
+exports.CALCOM_OAUTH_TOKEN_URL = CALCOM_OAUTH_TOKEN_URL;
+exports.CALCOM_RATE_LIMIT_LIMIT_HEADER = CALCOM_RATE_LIMIT_LIMIT_HEADER;
+exports.CALCOM_RATE_LIMIT_REMAINING_HEADER = CALCOM_RATE_LIMIT_REMAINING_HEADER;
+exports.CALCOM_RATE_LIMIT_RESET_HEADER = CALCOM_RATE_LIMIT_RESET_HEADER;
+exports.CALCOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE = CALCOM_TOO_MANY_REQUESTS_HTTP_STATUS_CODE;
+exports.CalcomOAuthAccessTokenError = CalcomOAuthAccessTokenError;
+exports.CalcomOAuthAuthFailureError = CalcomOAuthAuthFailureError;
+exports.CalcomServerError = CalcomServerError;
+exports.CalcomServerFetchResponseError = CalcomServerFetchResponseError;
+exports.CalcomTooManyRequestsError = CalcomTooManyRequestsError;
+exports.DEFAULT_CALCOM_API_RATE_LIMIT = DEFAULT_CALCOM_API_RATE_LIMIT;
+exports.DEFAULT_CALCOM_API_RATE_LIMIT_RESET_PERIOD = DEFAULT_CALCOM_API_RATE_LIMIT_RESET_PERIOD;
+exports.DEFAULT_CALCOM_RATE_LIMITED_TOO_MANY_REQUESTS_LOG_FUNCTION = DEFAULT_CALCOM_RATE_LIMITED_TOO_MANY_REQUESTS_LOG_FUNCTION;
+exports.calcomAccessTokenStringFactory = calcomAccessTokenStringFactory;
+exports.calcomApiVersionHeaders = calcomApiVersionHeaders;
+exports.calcomFactory = calcomFactory;
+exports.calcomOAuthAccessTokenFactory = calcomOAuthAccessTokenFactory;
+exports.calcomOAuthFactory = calcomOAuthFactory;
+exports.calcomRateLimitHeaderDetails = calcomRateLimitHeaderDetails;
+exports.calcomRateLimitedFetchHandler = calcomRateLimitedFetchHandler;
+exports.cancelBooking = cancelBooking;
+exports.createBooking = createBooking;
+exports.createEventType = createEventType;
+exports.createWebhook = createWebhook;
+exports.deleteEventType = deleteEventType;
+exports.deleteWebhook = deleteWebhook;
+exports.exchangeAuthorizationCode = exchangeAuthorizationCode;
+exports.getAvailableSlots = getAvailableSlots;
+exports.getBooking = getBooking;
+exports.getBusyTimes = getBusyTimes;
+exports.getCalendars = getCalendars;
+exports.getEventTypes = getEventTypes;
+exports.getMe = getMe;
+exports.getSchedules = getSchedules;
+exports.getWebhook = getWebhook;
+exports.getWebhooks = getWebhooks;
+exports.handleCalcomErrorFetch = handleCalcomErrorFetch;
+exports.handleCalcomErrorFetchFactory = handleCalcomErrorFetchFactory;
+exports.handleCalcomOAuthErrorFetch = handleCalcomOAuthErrorFetch;
+exports.logCalcomErrorToConsole = logCalcomErrorToConsole;
+exports.logCalcomOAuthErrorToConsole = logCalcomOAuthErrorToConsole;
+exports.logCalcomServerErrorFunction = logCalcomServerErrorFunction;
+exports.parseCalcomApiError = parseCalcomApiError;
+exports.parseCalcomApiServerErrorResponseData = parseCalcomApiServerErrorResponseData;
+exports.parseCalcomOAuthError = parseCalcomOAuthError;
+exports.parseCalcomOAuthServerErrorResponseData = parseCalcomOAuthServerErrorResponseData;
+exports.parseCalcomServerErrorData = parseCalcomServerErrorData;
+exports.refreshAccessToken = refreshAccessToken;
+exports.updateEventType = updateEventType;
+exports.updateWebhook = updateWebhook;