@dereekb/calcom 13.35.0 → 13.36.0

package/index.cjs.js

@@ -10,7 +10,7 @@ function _assert_this_initialized$1(self) {
     }
     return self;
 }
-function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -24,16 +24,16 @@ function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$5(fn) {
+function _async_to_generator$6(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);
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -61,7 +61,7 @@ function _create_class(Constructor, protoProps, staticProps) {
     if (protoProps) _defineProperties(Constructor.prototype, protoProps);
     return Constructor;
 }
-function _define_property$2(obj, key, value) {
+function _define_property$3(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -126,7 +126,7 @@ function _is_native_reflect_construct$1() {
         return !!result;
     })();
 }
-function _ts_generator$5(thisArg, body) {
+function _ts_generator$6(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -234,7 +234,7 @@ function _ts_generator$5(thisArg, body) {
         var _this;
         _this = _call_super$1(this, CalcomServerError, [
             error.message
-        ]), _define_property$2(_this, "error", void 0);
+        ]), _define_property$3(_this, "error", void 0);
         _this.error = error;
         return _this;
     }
@@ -257,7 +257,7 @@ function _ts_generator$5(thisArg, body) {
         var _this;
         _this = _call_super$1(this, CalcomServerFetchResponseError, [
             data
-        ]), _define_property$2(_this, "data", void 0), _define_property$2(_this, "responseError", void 0);
+        ]), _define_property$3(_this, "data", void 0), _define_property$3(_this, "responseError", void 0);
         _this.data = data;
         _this.responseError = responseError;
         return _this;
@@ -301,9 +301,9 @@ function _ts_generator$5(thisArg, body) {
     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() {
+            return _async_to_generator$6(function() {
                 var e, error;
-                return _ts_generator$5(this, function(_state) {
+                return _ts_generator$6(this, function(_state) {
                     switch(_state.label){
                         case 0:
                             _state.trys.push([
@@ -422,7 +422,7 @@ var CalcomTooManyRequestsError = /*#__PURE__*/ function(CalcomServerFetchRespons
     return result;
 }
 
-function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -436,22 +436,22 @@ function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$4(fn) {
+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$4(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
-function _ts_generator$4(thisArg, body) {
+function _ts_generator$5(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -552,6 +552,25 @@ function _ts_generator$4(thisArg, body) {
 }
 // MARK: Parser
 var logCalcomErrorToConsole = logCalcomServerErrorFunction('Calcom');
+/**
+ * Flattens a Cal.com API error response body into {@link CalcomServerErrorData}.
+ *
+ * Reads the nested `error` envelope when present, and otherwise treats the body as already
+ * flat — so an endpoint that returns a bare error object still yields its code and message.
+ *
+ * @param body - The parsed error response body.
+ * @returns The flattened error data.
+ */ function calcomServerErrorDataFromApiErrorResponseBody(body) {
+    var _ref, _ref1, _ref2;
+    var error = body.error, status = body.status;
+    var flatBody = body;
+    return {
+        code: (_ref = error === null || error === void 0 ? void 0 : error.code) !== null && _ref !== void 0 ? _ref : flatBody.code,
+        message: (_ref1 = error === null || error === void 0 ? void 0 : error.message) !== null && _ref1 !== void 0 ? _ref1 : flatBody.message,
+        details: (_ref2 = error === null || error === void 0 ? void 0 : error.details) !== null && _ref2 !== void 0 ? _ref2 : flatBody.details,
+        status: status !== null && status !== void 0 ? status : undefined
+    };
+}
 /**
  * Parses a FetchResponseError from a Cal.com API call into a typed CalcomServerError.
  * Attempts to extract JSON error data from the response body.
@@ -559,9 +578,9 @@ var logCalcomErrorToConsole = logCalcomServerErrorFunction('Calcom');
  * @param responseError - The fetch response error to parse.
  * @returns A parsed CalcomServerError, or undefined if the response body cannot be parsed.
  */ function parseCalcomApiError(responseError) {
-    return _async_to_generator$4(function() {
-        var data, result;
-        return _ts_generator$4(this, function(_state) {
+    return _async_to_generator$5(function() {
+        var body, result;
+        return _ts_generator$5(this, function(_state) {
             switch(_state.label){
                 case 0:
                     return [
@@ -571,9 +590,9 @@ var logCalcomErrorToConsole = logCalcomServerErrorFunction('Calcom');
                         })
                     ];
                 case 1:
-                    data = _state.sent();
-                    if (data) {
-                        result = parseCalcomApiServerErrorResponseData(data, responseError);
+                    body = _state.sent();
+                    if (body) {
+                        result = parseCalcomApiServerErrorResponseData(calcomServerErrorDataFromApiErrorResponseBody(body), responseError);
                     }
                     return [
                         2,
@@ -609,7 +628,7 @@ function _assert_this_initialized(self) {
     }
     return self;
 }
-function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -623,16 +642,16 @@ function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$3(fn) {
+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$3(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -647,7 +666,7 @@ function _class_call_check(instance, Constructor) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _define_property$1(obj, key, value) {
+function _define_property$2(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -704,7 +723,7 @@ function _is_native_reflect_construct() {
         return !!result;
     })();
 }
-function _ts_generator$3(thisArg, body) {
+function _ts_generator$4(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -816,7 +835,7 @@ function _ts_generator$3(thisArg, body) {
         var _this;
         _this = _call_super(this, CalcomOAuthAccessTokenError, [
             "CalcomOAuthAccessTokenError: ".concat(errorCode)
-        ]), _define_property$1(_this, "errorCode", void 0);
+        ]), _define_property$2(_this, "errorCode", void 0);
         _this.errorCode = errorCode;
         return _this;
     }
@@ -831,7 +850,7 @@ function _ts_generator$3(thisArg, body) {
         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);
+        ]), _define_property$2(_this, "reason", void 0);
         _this.reason = reason;
         return _this;
     }
@@ -845,9 +864,9 @@ var logCalcomOAuthErrorToConsole = logCalcomServerErrorFunction('CalcomOAuth');
  * @param responseError - The fetch response error to parse.
  * @returns A parsed CalcomServerError or CalcomOAuthAccessTokenError, or undefined if unparseable.
  */ function parseCalcomOAuthError(responseError) {
-    return _async_to_generator$3(function() {
+    return _async_to_generator$4(function() {
         var data, result;
-        return _ts_generator$3(this, function(_state) {
+        return _ts_generator$4(this, function(_state) {
             switch(_state.label){
                 case 0:
                     return [
@@ -895,7 +914,7 @@ var logCalcomOAuthErrorToConsole = logCalcomServerErrorFunction('CalcomOAuth');
 }
 var handleCalcomOAuthErrorFetch = handleCalcomErrorFetchFactory(parseCalcomOAuthError, logCalcomOAuthErrorToConsole);
 
-function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -909,22 +928,22 @@ function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$2(fn) {
+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$2(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
-function _ts_generator$2(thisArg, body) {
+function _ts_generator$3(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -1034,9 +1053,9 @@ function _ts_generator$2(thisArg, body) {
  * @__NO_SIDE_EFFECTS__
  */ function calcomAccessTokenStringFactory(calcomAccessTokenFactory) {
     return function() {
-        return _async_to_generator$2(function() {
+        return _async_to_generator$3(function() {
             var token;
-            return _ts_generator$2(this, function(_state) {
+            return _ts_generator$3(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         return [
@@ -1129,7 +1148,7 @@ var DEFAULT_CALCOM_RATE_LIMITED_TOO_MANY_REQUESTS_LOG_FUNCTION = function DEFAUL
  * The Cal.com API URL.
  */ var CALCOM_API_URL = 'https://api.cal.com/v2';
 
-function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -1143,22 +1162,22 @@ function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$1(fn) {
+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$1(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
-function _ts_generator$1(thisArg, body) {
+function _ts_generator$2(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -1274,9 +1293,9 @@ function _ts_generator$1(thisArg, body) {
         return fetch.fetchApiFetchService.makeFetch({
             baseUrl: CALCOM_API_URL,
             baseRequest: function baseRequest() {
-                return _async_to_generator$1(function() {
+                return _async_to_generator$2(function() {
                     var _tmp, _tmp1, _, _1;
-                    return _ts_generator$1(this, function(_state) {
+                    return _ts_generator$2(this, function(_state) {
                         switch(_state.label){
                             case 0:
                                 _tmp = {};
@@ -1376,7 +1395,7 @@ function _ts_generator$1(thisArg, body) {
     };
 }
 
-function _define_property(obj, key, value) {
+function _define_property$1(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -1406,7 +1425,7 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
  * @param version - The Cal.com API version string to include in the header.
  * @returns A headers record containing the cal-api-version header.
  */ function calcomApiVersionHeaders(version) {
-    return _define_property({}, CALCOM_API_VERSION_HEADER, version);
+    return _define_property$1({}, CALCOM_API_VERSION_HEADER, version);
 }
 
 /**
@@ -1462,6 +1481,8 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
  * @param context - The Cal.com API context (authenticated or public)
  * @returns Queries available slots for the given input.
  *
+ * The `cal-api-version` header is REQUIRED here — without it the endpoint 404s.
+ *
  * @see https://cal.com/docs/api-reference/v2/slots/get-available-time-slots-for-an-event-type
  *
  * @example
@@ -1472,8 +1493,8 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
  *   eventTypeId: 12345
  * });
  *
- * for (const [date, slots] of Object.entries(response.data.slots)) {
- *   console.log(date, slots.map(s => s.time));
+ * for (const [date, slots] of Object.entries(response.data)) {
+ *   console.log(date, slots.map(s => s.start));
  * }
  * ```
  */ function getAvailableSlots(context) {
@@ -1515,6 +1536,31 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
         });
     };
 }
+/**
+ * Retrieves the bookings visible to the authenticated user, newest page first.
+ *
+ * Paginated: read {@link CalcomGetBookingsResponse.pagination} rather than assuming `data` holds
+ * everything, as the endpoint caps a page even with no `take`.
+ *
+ * @param context - The Cal.com API context providing authentication and fetch capabilities.
+ * @returns Retrieves a page of bookings for the given input.
+ *
+ * @see https://cal.com/docs/api-reference/v2/bookings/get-all-bookings
+ *
+ * @example
+ * ```ts
+ * const response = await getBookings(context)({ take: 10, status: 'upcoming', sortStart: 'asc' });
+ * console.log(response.pagination.totalItems, response.data.map(b => b.uid));
+ * ```
+ */ function getBookings(context) {
+    return function(input) {
+        var params = fetch.makeUrlSearchParams(input);
+        return context.fetchJson("/bookings?".concat(params), {
+            method: 'GET',
+            headers: calcomApiVersionHeaders(CALCOM_API_VERSION_BOOKINGS)
+        });
+    };
+}
 /**
  * Retrieves a booking by its unique UID.
  *
@@ -1653,6 +1699,181 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
     };
 }
 
+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(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;
+}
+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
+        };
+    }
+}
 /**
  * Retrieves all connected calendars and the destination calendar for the authenticated user.
  *
@@ -1664,7 +1885,7 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
  * @example
  * ```ts
  * const response = await getCalendars(context)();
- * response.data.connectedCalendars.forEach(cc => console.log(cc.integration));
+ * response.data.connectedCalendars.forEach(cc => console.log(cc.integration.slug, cc.calendars.length));
  * ```
  */ function getCalendars(context) {
     return function() {
@@ -1675,7 +1896,35 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
     };
 }
 /**
- * Retrieves busy time ranges across the user's connected calendars for a given date range.
+ * Selects the calendars to load busy times from, out of a set of connected calendars.
+ *
+ * Prefers the calendars Cal.com is configured to check for conflicts (`isSelected`), and falls
+ * back to a connection's primary calendar when that connection has nothing selected.
+ *
+ * @param connectedCalendars - The connected calendars to select from.
+ * @returns The calendars to load.
+ */ function calcomCalendarsToLoadFromConnectedCalendars(connectedCalendars) {
+    return connectedCalendars.flatMap(function(connection) {
+        var selectedCalendars = connection.calendars.filter(function(x) {
+            return x.isSelected;
+        });
+        var primaryCalendars = connection.primary ? [
+            connection.primary
+        ] : [];
+        var calendars = selectedCalendars.length > 0 ? selectedCalendars : primaryCalendars;
+        return calendars.map(function(x) {
+            return {
+                credentialId: x.credentialId,
+                externalId: x.externalId
+            };
+        });
+    });
+}
+/**
+ * Retrieves busy time ranges across the given calendars for a date range.
+ *
+ * A caller cannot address this endpoint without first knowing its calendars, so this is the
+ * single-request primitive — see {@link getBusyTimesForConnectedCalendars} to resolve them too.
  *
  * @param context - The Cal.com API context providing authentication and fetch capabilities.
  * @returns Retrieves busy time ranges for a date range.
@@ -1686,17 +1935,22 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
  * ```ts
  * const response = await getBusyTimes(context)({
  *   dateFrom: '2026-03-17',
- *   dateTo: '2026-03-24'
+ *   dateTo: '2026-03-24',
+ *   timeZone: 'America/Chicago',
+ *   calendarsToLoad: [{ credentialId: 1845764, externalId: 'someone@example.com' }]
  * });
  * response.data.forEach(bt => console.log(bt.start, bt.end));
  * ```
  */ function getBusyTimes(context) {
     return function(input) {
-        var _input_calendarsToLoad;
         var params = fetch.makeUrlSearchParams({
+            timeZone: input.timeZone,
+            loggedInUsersTz: input.loggedInUsersTz,
             dateFrom: input.dateFrom,
             dateTo: input.dateTo,
-            calendarsToLoad: (_input_calendarsToLoad = input.calendarsToLoad) === null || _input_calendarsToLoad === void 0 ? void 0 : _input_calendarsToLoad.join(',')
+            calendarsToLoad: input.calendarsToLoad
+        }, {
+            useBracketNotation: true
         });
         return context.fetchJson("/calendars/busy-times?".concat(params), {
             method: 'GET',
@@ -1704,7 +1958,112 @@ var CALCOM_API_VERSION_HEADER = 'cal-api-version';
         });
     };
 }
+/**
+ * Retrieves busy time ranges across the user's connected calendars for a date range.
+ *
+ * Convenience over {@link getBusyTimes}: loads the connected calendars first and derives
+ * `calendarsToLoad` via {@link calcomCalendarsToLoadFromConnectedCalendars}, so a caller does not
+ * have to know Cal.com's `isSelected`/primary selection rule. Issues two requests.
+ *
+ * @param context - The Cal.com API context providing authentication and fetch capabilities.
+ * @returns Retrieves busy time ranges across the user's connected calendars.
+ *
+ * @example
+ * ```ts
+ * const response = await getBusyTimesForConnectedCalendars(context)({
+ *   dateFrom: '2026-03-17',
+ *   dateTo: '2026-03-24',
+ *   loggedInUsersTz: 'UTC'
+ * });
+ * ```
+ */ function getBusyTimesForConnectedCalendars(context) {
+    return function(input) {
+        return _async_to_generator$1(function() {
+            var calendarsResponse, calendarsToLoad;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            getCalendars(context)()
+                        ];
+                    case 1:
+                        calendarsResponse = _state.sent();
+                        calendarsToLoad = calcomCalendarsToLoadFromConnectedCalendars(calendarsResponse.data.connectedCalendars);
+                        return [
+                            2,
+                            getBusyTimes(context)(_object_spread_props(_object_spread({}, input), {
+                                calendarsToLoad: calendarsToLoad
+                            }))
+                        ];
+                }
+            });
+        })();
+    };
+}
 
+/**
+ * All {@link CalcomWebhookTimeRelativeTrigger} values.
+ */ var ALL_CALCOM_WEBHOOK_TIME_RELATIVE_TRIGGERS = [
+    'AFTER_HOSTS_CAL_VIDEO_NO_SHOW',
+    'AFTER_GUESTS_CAL_VIDEO_NO_SHOW'
+];
+/**
+ * All {@link CalcomWebhookVersion} values, oldest first.
+ */ var ALL_CALCOM_WEBHOOK_VERSIONS = [
+    '2021-10-20',
+    '2026-07-27'
+];
+/**
+ * All {@link CalcomWebhookTimeUnit} values, smallest first.
+ */ var ALL_CALCOM_WEBHOOK_TIME_UNITS = [
+    'MINUTE',
+    'HOUR',
+    'DAY'
+];
+/**
+ * Maps each {@link CalcomWebhookTimeUnit} to the equivalent `@dereekb/util` {@link TimeUnit}.
+ */ var CALCOM_WEBHOOK_TIME_UNIT_TIME_UNIT_MAP = {
+    MINUTE: 'min',
+    HOUR: 'h',
+    DAY: 'd'
+};
+/**
+ * Converts a Cal.com webhook time offset to a `@dereekb/util` {@link TimeDuration}, so the
+ * duration utilities (`timeDurationToMilliseconds()`, `convertTimeDuration()`, ...) apply to it.
+ *
+ * @param offset - The webhook time offset to convert.
+ * @returns The equivalent TimeDuration.
+ *
+ * @example
+ * ```ts
+ * timeDurationToMilliseconds(calcomWebhookTimeOffsetToTimeDuration({ time: 5, timeUnit: 'MINUTE' })); // 300000
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function calcomWebhookTimeOffsetToTimeDuration(offset) {
+    return {
+        amount: offset.time,
+        unit: CALCOM_WEBHOOK_TIME_UNIT_TIME_UNIT_MAP[offset.timeUnit]
+    };
+}
+/**
+ * Reads a webhook's {@link CalcomWebhookTimeOffset} out of the sibling `time`/`timeUnit` fields.
+ *
+ * Returns undefined unless both halves are present, as the API returns them null on a webhook
+ * with no {@link CalcomWebhookTimeRelativeTrigger} and a magnitude with no unit means nothing.
+ *
+ * @param webhook - The webhook to read the offset from.
+ * @returns The webhook's time offset, or undefined when it has none.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function calcomWebhookTimeOffsetFromWebhook(webhook) {
+    var time = webhook.time, timeUnit = webhook.timeUnit;
+    return time != null && timeUnit != null ? {
+        time: time,
+        timeUnit: timeUnit
+    } : undefined;
+}
 /**
  * Creates a webhook subscription for the authenticated user. Webhooks notify your app
  * when specified events occur (e.g., bookings created, cancelled, rescheduled).
@@ -2428,6 +2787,9 @@ function _ts_generator(thisArg, body) {
 }
 
 exports.ALL_CALCOM_OAUTH_SCOPES = ALL_CALCOM_OAUTH_SCOPES;
+exports.ALL_CALCOM_WEBHOOK_TIME_RELATIVE_TRIGGERS = ALL_CALCOM_WEBHOOK_TIME_RELATIVE_TRIGGERS;
+exports.ALL_CALCOM_WEBHOOK_TIME_UNITS = ALL_CALCOM_WEBHOOK_TIME_UNITS;
+exports.ALL_CALCOM_WEBHOOK_VERSIONS = ALL_CALCOM_WEBHOOK_VERSIONS;
 exports.CALCOM_API_KEY_ACCESS_TOKEN_EXPIRATION = CALCOM_API_KEY_ACCESS_TOKEN_EXPIRATION;
 exports.CALCOM_API_URL = CALCOM_API_URL;
 exports.CALCOM_API_VERSION_BOOKINGS = CALCOM_API_VERSION_BOOKINGS;
@@ -2448,6 +2810,7 @@ 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.CALCOM_WEBHOOK_TIME_UNIT_TIME_UNIT_MAP = CALCOM_WEBHOOK_TIME_UNIT_TIME_UNIT_MAP;
 exports.CalcomOAuthAccessTokenError = CalcomOAuthAccessTokenError;
 exports.CalcomOAuthAuthFailureError = CalcomOAuthAuthFailureError;
 exports.CalcomServerError = CalcomServerError;
@@ -2461,12 +2824,16 @@ exports.calcomAccessTokenFromTokenResponse = calcomAccessTokenFromTokenResponse;
 exports.calcomAccessTokenStringFactory = calcomAccessTokenStringFactory;
 exports.calcomApiVersionHeaders = calcomApiVersionHeaders;
 exports.calcomAuthCredentialFromValues = calcomAuthCredentialFromValues;
+exports.calcomCalendarsToLoadFromConnectedCalendars = calcomCalendarsToLoadFromConnectedCalendars;
 exports.calcomFactory = calcomFactory;
 exports.calcomOAuthAccessTokenFactory = calcomOAuthAccessTokenFactory;
 exports.calcomOAuthAuthorizeUrlFactory = calcomOAuthAuthorizeUrlFactory;
 exports.calcomOAuthFactory = calcomOAuthFactory;
 exports.calcomRateLimitHeaderDetails = calcomRateLimitHeaderDetails;
 exports.calcomRateLimitedFetchHandler = calcomRateLimitedFetchHandler;
+exports.calcomServerErrorDataFromApiErrorResponseBody = calcomServerErrorDataFromApiErrorResponseBody;
+exports.calcomWebhookTimeOffsetFromWebhook = calcomWebhookTimeOffsetFromWebhook;
+exports.calcomWebhookTimeOffsetToTimeDuration = calcomWebhookTimeOffsetToTimeDuration;
 exports.cancelBooking = cancelBooking;
 exports.createBooking = createBooking;
 exports.createEventType = createEventType;
@@ -2476,7 +2843,9 @@ exports.deleteWebhook = deleteWebhook;
 exports.exchangeAuthorizationCode = exchangeAuthorizationCode;
 exports.getAvailableSlots = getAvailableSlots;
 exports.getBooking = getBooking;
+exports.getBookings = getBookings;
 exports.getBusyTimes = getBusyTimes;
+exports.getBusyTimesForConnectedCalendars = getBusyTimesForConnectedCalendars;
 exports.getCalendars = getCalendars;
 exports.getEventTypes = getEventTypes;
 exports.getMe = getMe;