@wix/bookings 1.0.72 → 1.0.73

package/build/es/src/bookings-calendar-v2-external-calendar.universal.js

@@ -0,0 +1,827 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { serializer, transformError } from '@wix/metro-runtime/velo';
+import * as ambassadorWixBookingsCalendarV2ExternalCalendar from './bookings-calendar-v2-external-calendar.http';
+let __verbose = false;
+function __log(...args) {
+    __verbose && console.log(...args);
+}
+function __inspect(obj) {
+    return obj;
+}
+export const __debug = {
+    verboseLogging: {
+        on: () => (__verbose = true),
+        off: () => (__verbose = false),
+    },
+};
+const _toVeloEntity = '$';
+const _fromVeloEntity = '$';
+export var CalendarType;
+(function (CalendarType) {
+    CalendarType["UNDEFINED"] = "UNDEFINED";
+    CalendarType["GOOGLE"] = "GOOGLE";
+    CalendarType["I_CAL"] = "I_CAL";
+    /** Use `MICROSOFT` instead. */
+    CalendarType["OUTLOOK"] = "OUTLOOK";
+    /** Use `MICROSOFT` instead. */
+    CalendarType["OFFICE_365"] = "OFFICE_365";
+    CalendarType["MICROSOFT"] = "MICROSOFT";
+    CalendarType["OTHER"] = "OTHER";
+})(CalendarType || (CalendarType = {}));
+export var ConnectMethod;
+(function (ConnectMethod) {
+    ConnectMethod["UNDEFINED"] = "UNDEFINED";
+    ConnectMethod["OAUTH"] = "OAUTH";
+    ConnectMethod["CREDENTIALS"] = "CREDENTIALS";
+})(ConnectMethod || (ConnectMethod = {}));
+export var ListEventFromCalendars;
+(function (ListEventFromCalendars) {
+    /** Dont use. */
+    ListEventFromCalendars["UNDEFINED"] = "UNDEFINED";
+    /** Listing events from the external calendar is not supported. */
+    ListEventFromCalendars["NOT_SUPPORTED"] = "NOT_SUPPORTED";
+    /** Listing events from the primary external calendar only. */
+    ListEventFromCalendars["PRIMARY_CALENDAR_ONLY"] = "PRIMARY_CALENDAR_ONLY";
+    /**
+     * Listing events from specific external calendars.
+     * The external calendars can be listed using the `ExternalCalendarService.ListCalendars` API.
+     */
+    ListEventFromCalendars["SPECIFIC_CALENDARS"] = "SPECIFIC_CALENDARS";
+})(ListEventFromCalendars || (ListEventFromCalendars = {}));
+export var SyncToCalendar;
+(function (SyncToCalendar) {
+    /** Dont use. */
+    SyncToCalendar["UNDEFINED"] = "UNDEFINED";
+    /** Syncing Wix calendar sessions to the external calendar is not supported. */
+    SyncToCalendar["NOT_SUPPORTED"] = "NOT_SUPPORTED";
+    /** Syncing Wix calendar sessions to the primary external calendar only. */
+    SyncToCalendar["PRIMARY_CALENDAR_ONLY"] = "PRIMARY_CALENDAR_ONLY";
+    /** Syncing Wix calendar sessions to a specific external calendar. */
+    SyncToCalendar["SPECIFIC_CALENDAR"] = "SPECIFIC_CALENDAR";
+    /** Syncing Wix calendar sessions to a new external calendar. */
+    SyncToCalendar["DEDICATED_CALENDAR"] = "DEDICATED_CALENDAR";
+})(SyncToCalendar || (SyncToCalendar = {}));
+export var Status;
+(function (Status) {
+    /** Dont use. */
+    Status["UNDEFINED"] = "UNDEFINED";
+    /** External calendar is connected to the corresponding schedule id. */
+    Status["CONNECTED"] = "CONNECTED";
+    /** Sync in progress. */
+    Status["SYNC_IN_PROGRESS"] = "SYNC_IN_PROGRESS";
+    /** Calendars are in-sync. */
+    Status["SYNCED"] = "SYNCED";
+    /** External calender is disconnected. */
+    Status["DISCONNECTED"] = "DISCONNECTED";
+    /** The calendars sync is in error state. */
+    Status["ERROR"] = "ERROR";
+})(Status || (Status = {}));
+export var ErrorReason;
+(function (ErrorReason) {
+    /** Empty or error reason is unknown. */
+    ErrorReason["UNDEFINED"] = "UNDEFINED";
+    /** External calendar access token revoked. */
+    ErrorReason["TOKEN_REVOKED"] = "TOKEN_REVOKED";
+    /** External calendar creation failed. */
+    ErrorReason["EXTERNAL_CALENDAR_CREATION_FAILED"] = "EXTERNAL_CALENDAR_CREATION_FAILED";
+    /** External Calendar was deleted. */
+    ErrorReason["EXTERNAL_CALENDAR_DELETED"] = "EXTERNAL_CALENDAR_DELETED";
+})(ErrorReason || (ErrorReason = {}));
+export var SyncToErrorReason;
+(function (SyncToErrorReason) {
+    /** No sync error. */
+    SyncToErrorReason["UNDEFINED"] = "UNDEFINED";
+    /** Could not create calendar to sync sessions to. */
+    SyncToErrorReason["CALENDAR_CREATION_FAILURE"] = "CALENDAR_CREATION_FAILURE";
+    /** Calendar was deleted while sync was in progress. */
+    SyncToErrorReason["CALENDAR_DELETED"] = "CALENDAR_DELETED";
+})(SyncToErrorReason || (SyncToErrorReason = {}));
+export var Day;
+(function (Day) {
+    /** Undefined. */
+    Day["UNDEFINED"] = "UNDEFINED";
+    /** Monday. */
+    Day["MON"] = "MON";
+    /** Tuesday. */
+    Day["TUE"] = "TUE";
+    /** Wednesday. */
+    Day["WED"] = "WED";
+    /** Thursday. */
+    Day["THU"] = "THU";
+    /** Friday. */
+    Day["FRI"] = "FRI";
+    /** Saturday. */
+    Day["SAT"] = "SAT";
+    /** Sunday. */
+    Day["SUN"] = "SUN";
+})(Day || (Day = {}));
+export var Transparency;
+(function (Transparency) {
+    Transparency["UNDEFINED"] = "UNDEFINED";
+    /** The schedule can have available slots during the session. */
+    Transparency["FREE"] = "FREE";
+    /** The schedule cannot have available slots during the session. Default value. */
+    Transparency["BUSY"] = "BUSY";
+})(Transparency || (Transparency = {}));
+export var RecurringIntervalType;
+(function (RecurringIntervalType) {
+    /** The default value. Sessions for this interval will be of type EVENT. */
+    RecurringIntervalType["UNDEFINED"] = "UNDEFINED";
+    /** A recurring interval of events */
+    RecurringIntervalType["EVENT"] = "EVENT";
+    /** Deprecated */
+    RecurringIntervalType["TIME_AVAILABILITY"] = "TIME_AVAILABILITY";
+    /** A recurring interval for availability */
+    RecurringIntervalType["AVAILABILITY"] = "AVAILABILITY";
+})(RecurringIntervalType || (RecurringIntervalType = {}));
+export var LocationType;
+(function (LocationType) {
+    LocationType["UNDEFINED"] = "UNDEFINED";
+    LocationType["OWNER_BUSINESS"] = "OWNER_BUSINESS";
+    LocationType["OWNER_CUSTOM"] = "OWNER_CUSTOM";
+    LocationType["CUSTOM"] = "CUSTOM";
+})(LocationType || (LocationType = {}));
+/** For future use */
+export var LocationStatus;
+(function (LocationStatus) {
+    LocationStatus["ACTIVE"] = "ACTIVE";
+    LocationStatus["INACTIVE"] = "INACTIVE";
+})(LocationStatus || (LocationStatus = {}));
+/** For future use */
+export var LocationsLocationType;
+(function (LocationsLocationType) {
+    LocationsLocationType["UNKNOWN"] = "UNKNOWN";
+    LocationsLocationType["BRANCH"] = "BRANCH";
+    LocationsLocationType["OFFICES"] = "OFFICES";
+    LocationsLocationType["RECEPTION"] = "RECEPTION";
+    LocationsLocationType["HEADQUARTERS"] = "HEADQUARTERS";
+})(LocationsLocationType || (LocationsLocationType = {}));
+/** Enumerates the days of the week. */
+export var DayOfWeek;
+(function (DayOfWeek) {
+    DayOfWeek["MONDAY"] = "MONDAY";
+    DayOfWeek["TUESDAY"] = "TUESDAY";
+    DayOfWeek["WEDNESDAY"] = "WEDNESDAY";
+    DayOfWeek["THURSDAY"] = "THURSDAY";
+    DayOfWeek["FRIDAY"] = "FRIDAY";
+    DayOfWeek["SATURDAY"] = "SATURDAY";
+    DayOfWeek["SUNDAY"] = "SUNDAY";
+})(DayOfWeek || (DayOfWeek = {}));
+export var ApprovalStatus;
+(function (ApprovalStatus) {
+    /** Default. */
+    ApprovalStatus["UNDEFINED"] = "UNDEFINED";
+    /** Pending business approval. */
+    ApprovalStatus["PENDING"] = "PENDING";
+    /** Approved by the business. */
+    ApprovalStatus["APPROVED"] = "APPROVED";
+    /** Declined by the business. */
+    ApprovalStatus["DECLINED"] = "DECLINED";
+})(ApprovalStatus || (ApprovalStatus = {}));
+export var ScheduleStatus;
+(function (ScheduleStatus) {
+    ScheduleStatus["UNDEFINED"] = "UNDEFINED";
+    /** The default value when the schedule is created. */
+    ScheduleStatus["CREATED"] = "CREATED";
+    /** The schedule has been canceled. */
+    ScheduleStatus["CANCELLED"] = "CANCELLED";
+})(ScheduleStatus || (ScheduleStatus = {}));
+export var ConferenceType;
+(function (ConferenceType) {
+    ConferenceType["UNDEFINED"] = "UNDEFINED";
+    /** API-generated online meeting. */
+    ConferenceType["ONLINE_MEETING_PROVIDER"] = "ONLINE_MEETING_PROVIDER";
+    /** User-defined meeting. */
+    ConferenceType["CUSTOM"] = "CUSTOM";
+})(ConferenceType || (ConferenceType = {}));
+export var SessionStatus;
+(function (SessionStatus) {
+    SessionStatus["UNDEFINED"] = "UNDEFINED";
+    /** The session is confirmed. Default status. */
+    SessionStatus["CONFIRMED"] = "CONFIRMED";
+    /**
+     * The session is cancelled.
+     * A cancelled session can be the cancellation of a recurring session that should no longer be displayed or a deleted single session.
+     * The ListSessions returns cancelled sessions only if 'includeDelete' flag is set to true.
+     */
+    SessionStatus["CANCELLED"] = "CANCELLED";
+})(SessionStatus || (SessionStatus = {}));
+export var SessionType;
+(function (SessionType) {
+    SessionType["UNDEFINED"] = "UNDEFINED";
+    /**
+     * The session creates an event on the calendar for the owner of the schedule that the session belongs to.
+     * Default type.
+     */
+    SessionType["EVENT"] = "EVENT";
+    /** The session represents a resource's available working hours. */
+    SessionType["WORKING_HOURS"] = "WORKING_HOURS";
+    /** Deprecated. please use WORKING_HOURS */
+    SessionType["TIME_AVAILABILITY"] = "TIME_AVAILABILITY";
+    /** Deprecated. The session represents a resource's available hours. please use WORKING_HOURS */
+    SessionType["AVAILABILITY"] = "AVAILABILITY";
+})(SessionType || (SessionType = {}));
+const _connectByCredentialsRequest = {};
+const _connectByCredentialsResponse = {};
+const _connectByOAuthRequest = {};
+const _connectByOAuthResponse = {};
+const _disconnectRequest = {};
+const _disconnectResponse = {};
+const _getConnectionRequest = {};
+const _getConnectionResponse = {};
+const _listCalendarsRequest = {};
+const _listCalendarsResponse = {};
+const _listConnectionsRequest = {};
+const _listConnectionsResponse = {};
+const _listEventsRequest = {};
+const _listEventsResponse = {};
+const _listProvidersRequest = {};
+const _listProvidersResponse = {};
+const _updateSyncConfigRequest = {};
+const _updateSyncConfigResponse = {};
+/**
+ * Retrieves a list of the external calendar providers for which the site supports integration.
+ *
+ *
+ * The list of external calendar providers includes:
+ *
+ * + External calendar providers that are supported by default, such as Google, Apple, and Microsoft.
+ * + External calenders for which the site owner has enabled integration by installing an app.
+ *
+ * For each external calendar provider, the list contains information about supported connection methods and features.
+ * For each provider, check `features.connectMethods` to find out whether to use [Connect By Credentials](#connect-by-credentials) or [Connect By OAuth](#connect-by-o-auth) to establish a connection.
+ * @public
+ * @documentationMaturity preview
+ */
+export function listProviders() {
+    var _a, _b, _c;
+    return __awaiter(this, arguments, void 0, function* () {
+        const requestTransformation = {};
+        const responseTransformation = '$';
+        // @ts-ignore
+        const { httpClient, sideEffects } = arguments[0];
+        const { toAmbassadorRequest } = serializer({
+            rootSchema: _listProvidersRequest,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _fromVeloEntity,
+            },
+            customTransformation: requestTransformation,
+        });
+        const { fromJSON } = serializer({
+            rootSchema: _listProvidersResponse,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _toVeloEntity,
+            },
+            customTransformation: responseTransformation,
+        });
+        const payload = toAmbassadorRequest([]);
+        const reqOpts = ambassadorWixBookingsCalendarV2ExternalCalendar.listProviders(payload);
+        __log(`"ListProviders" sending request with: ${__inspect(reqOpts)}`);
+        (_a = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSiteCall) === null || _a === void 0 ? void 0 : _a.call(sideEffects);
+        try {
+            const result = yield httpClient.request(reqOpts);
+            (_b = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSuccess) === null || _b === void 0 ? void 0 : _b.call(sideEffects, result);
+            return fromJSON(result.data);
+        }
+        catch (err) {
+            const transformedError = transformError(err, requestTransformation, []);
+            (_c = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onError) === null || _c === void 0 ? void 0 : _c.call(sideEffects, err);
+            throw transformedError;
+        }
+    });
+}
+/**
+ * Retrieves an external calendar connection by ID.
+ *
+ *
+ * The external calendar connection contains details of the connection between a Wix site's calendar and calendars hosted by an external provider.
+ *
+ * The `syncConfig` property contains configuration details for importing events from an external calendar, exporting events to an external calendar, or both.
+ * @param connectionId - ID of the connection to retrieve.
+ * @public
+ * @documentationMaturity preview
+ * @requiredField connectionId
+ */
+export function getConnection(connectionId) {
+    var _a, _b, _c;
+    return __awaiter(this, arguments, void 0, function* () {
+        const requestTransformation = { connectionId: '$[0]' };
+        const responseTransformation = '$';
+        // @ts-ignore
+        const { httpClient, sideEffects } = arguments[1];
+        const { toAmbassadorRequest } = serializer({
+            rootSchema: _getConnectionRequest,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _fromVeloEntity,
+            },
+            customTransformation: requestTransformation,
+        });
+        const { fromJSON } = serializer({
+            rootSchema: _getConnectionResponse,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _toVeloEntity,
+            },
+            customTransformation: responseTransformation,
+        });
+        const payload = toAmbassadorRequest([connectionId]);
+        const reqOpts = ambassadorWixBookingsCalendarV2ExternalCalendar.getConnection(payload);
+        __log(`"GetConnection" sending request with: ${__inspect(reqOpts)}`);
+        (_a = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSiteCall) === null || _a === void 0 ? void 0 : _a.call(sideEffects);
+        try {
+            const result = yield httpClient.request(reqOpts);
+            (_b = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSuccess) === null || _b === void 0 ? void 0 : _b.call(sideEffects, result);
+            return fromJSON(result.data);
+        }
+        catch (err) {
+            const transformedError = transformError(err, requestTransformation, [
+                'connectionId',
+            ]);
+            (_c = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onError) === null || _c === void 0 ? void 0 : _c.call(sideEffects, err);
+            throw transformedError;
+        }
+    });
+}
+/**
+ * Retrieves a list of external calendar connections.
+ *
+ *
+ * Each external calendar connections contains details of a connection between a Wix site's calendar and calendars hosted by an external provider.
+ *
+ * The `syncConfig` property of each connection contains configuration details for importing events from an external calendar, exporting events to an external calendar, or both.
+ * @public
+ * @documentationMaturity preview
+ */
+export function listConnections(options) {
+    var _a, _b, _c;
+    return __awaiter(this, arguments, void 0, function* () {
+        const requestTransformation = {
+            scheduleIds: '$[0].scheduleIds',
+            partialFailure: '$[0].partialFailure',
+        };
+        const responseTransformation = '$';
+        // @ts-ignore
+        const { httpClient, sideEffects } = arguments[1];
+        const { toAmbassadorRequest } = serializer({
+            rootSchema: _listConnectionsRequest,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _fromVeloEntity,
+            },
+            customTransformation: requestTransformation,
+        });
+        const { fromJSON } = serializer({
+            rootSchema: _listConnectionsResponse,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _toVeloEntity,
+            },
+            customTransformation: responseTransformation,
+        });
+        const payload = toAmbassadorRequest([options]);
+        const reqOpts = ambassadorWixBookingsCalendarV2ExternalCalendar.listConnections(payload);
+        __log(`"ListConnections" sending request with: ${__inspect(reqOpts)}`);
+        (_a = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSiteCall) === null || _a === void 0 ? void 0 : _a.call(sideEffects);
+        try {
+            const result = yield httpClient.request(reqOpts);
+            (_b = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSuccess) === null || _b === void 0 ? void 0 : _b.call(sideEffects, result);
+            return fromJSON(result.data);
+        }
+        catch (err) {
+            const transformedError = transformError(err, requestTransformation, [
+                'options',
+            ]);
+            (_c = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onError) === null || _c === void 0 ? void 0 : _c.call(sideEffects, err);
+            throw transformedError;
+        }
+    });
+}
+/**
+ * Connects to an external calendar using the OAuth authorization protocol.
+ *
+ *
+ * The authorization flow should take place as follows:
+ *
+ * 1. Send a request to the endpoint with the appropriate parameters.
+ * 2. Redirect the user to the URL received in the response.
+ * 3. The user authorizes access.
+ * 4. The user is redirected to the URL you provide in the `redirectUrl` body parameter, with a query parameter `connectionId` containing the new connection ID.
+ *
+ * If the attempt to connect fails, the user is still redirected to the URL you provide in the `redirectUrl` body parameter,
+ * but with a query parameter `error` containing one of the following values:
+ *
+ * - `reject`: The user rejected the authorization request.
+ * - `unsupported`: Connecting to the user's external account type is not supported by the provider.
+ * - `internal`: An error unrelated to the client or the request that prevents the server from fulfilling the request.
+ *
+ * Once a connection is successfully created, use [List Events](#list-events) to obtain an up-to-date list of events in the connected external calendars.
+ *
+ * This endpoint validates that the specified schedule is owned by the Wix user connecting the calendar,
+ * or that the caller has the Manage External Calendars or Manage Business Calendar permission scope.
+ *
+ * If the schedule's ownership changes, the connection to the external calendar is automatically disconnected.
+ *
+ * > **Note:**
+ * > Use [List Providers](#list-providers) to find out whether to connect to a particular provider using this endpoint or [Connect by Credentials](#connect-by-credentials).
+ * @param providerId - ID of the external calendar provider. Find this with the [List Providers](#list-providers) endpoint.
+ * @param scheduleId - ID of the schedule to connect with the external calendar account.
+ * @param redirectUrl - URL to redirect the user to after they authorize access to the external calendar account.
+ *
+ * If the connection is successfully established, the user is redirected to this URL with a query parameter `connectionId` containing the new connection ID.
+ * If the attempt to connect fails, the user is redirected to this URL with a query parameter `error` containing the error type.
+ * @public
+ * @documentationMaturity preview
+ * @requiredField providerId
+ * @requiredField redirectUrl
+ * @requiredField scheduleId
+ */
+export function connectByOAuth(providerId, scheduleId, redirectUrl) {
+    var _a, _b, _c;
+    return __awaiter(this, arguments, void 0, function* () {
+        const requestTransformation = {
+            providerId: '$[0]',
+            scheduleId: '$[1]',
+            redirectUrl: '$[2]',
+        };
+        const responseTransformation = '$';
+        // @ts-ignore
+        const { httpClient, sideEffects } = arguments[3];
+        const { toAmbassadorRequest } = serializer({
+            rootSchema: _connectByOAuthRequest,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _fromVeloEntity,
+            },
+            customTransformation: requestTransformation,
+        });
+        const { fromJSON } = serializer({
+            rootSchema: _connectByOAuthResponse,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _toVeloEntity,
+            },
+            customTransformation: responseTransformation,
+        });
+        const payload = toAmbassadorRequest([providerId, scheduleId, redirectUrl]);
+        const reqOpts = ambassadorWixBookingsCalendarV2ExternalCalendar.connectByOAuth(payload);
+        __log(`"ConnectByOAuth" sending request with: ${__inspect(reqOpts)}`);
+        (_a = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSiteCall) === null || _a === void 0 ? void 0 : _a.call(sideEffects);
+        try {
+            const result = yield httpClient.request(reqOpts);
+            (_b = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSuccess) === null || _b === void 0 ? void 0 : _b.call(sideEffects, result);
+            return fromJSON(result.data);
+        }
+        catch (err) {
+            const transformedError = transformError(err, requestTransformation, [
+                'providerId',
+                'scheduleId',
+                'redirectUrl',
+            ]);
+            (_c = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onError) === null || _c === void 0 ? void 0 : _c.call(sideEffects, err);
+            throw transformedError;
+        }
+    });
+}
+/**
+ * Connects to an external calendar by directly providing the external calendar account credentials.
+ *
+ *
+ * Once a connection is successfully created, use [List Events](#list-events) to obtain an up-to-date list of events in the connected external calendars.
+ *
+ * This endpoint validates that the specified schedule is owned by the Wix user connecting the calendar,
+ * or that the caller has the Manage External Calendars or Manage Business Calendar permission scope.
+ *
+ * If the schedule's ownership changes, the connection to the external calendar is automatically disconnected.
+ *
+ * > **Note:**
+ * > Use [List Providers](#list-providers) to find out whether to connect to a particular provider using this endpoint or [Connect by OAuth](#connect-by-o-auth).
+ * @param providerId - ID of the external calendar provider. Find this with the [List Providers](#list-providers) endpoint.
+ * @param scheduleId - ID of the schedule to connect with the external calendar account.
+ * @param email - Email address for the external calendar account.
+ * @param password - Password for the external calendar account.
+ * @public
+ * @documentationMaturity preview
+ * @requiredField email
+ * @requiredField password
+ * @requiredField providerId
+ * @requiredField scheduleId
+ */
+export function connectByCredentials(providerId, scheduleId, email, password) {
+    var _a, _b, _c;
+    return __awaiter(this, arguments, void 0, function* () {
+        const requestTransformation = {
+            providerId: '$[0]',
+            scheduleId: '$[1]',
+            email: '$[2]',
+            password: '$[3]',
+        };
+        const responseTransformation = '$';
+        // @ts-ignore
+        const { httpClient, sideEffects } = arguments[4];
+        const { toAmbassadorRequest } = serializer({
+            rootSchema: _connectByCredentialsRequest,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _fromVeloEntity,
+            },
+            customTransformation: requestTransformation,
+        });
+        const { fromJSON } = serializer({
+            rootSchema: _connectByCredentialsResponse,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _toVeloEntity,
+            },
+            customTransformation: responseTransformation,
+        });
+        const payload = toAmbassadorRequest([
+            providerId,
+            scheduleId,
+            email,
+            password,
+        ]);
+        const reqOpts = ambassadorWixBookingsCalendarV2ExternalCalendar.connectByCredentials(payload);
+        __log(`"ConnectByCredentials" sending request with: ${__inspect(reqOpts)}`);
+        (_a = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSiteCall) === null || _a === void 0 ? void 0 : _a.call(sideEffects);
+        try {
+            const result = yield httpClient.request(reqOpts);
+            (_b = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSuccess) === null || _b === void 0 ? void 0 : _b.call(sideEffects, result);
+            return fromJSON(result.data);
+        }
+        catch (err) {
+            const transformedError = transformError(err, requestTransformation, [
+                'providerId',
+                'scheduleId',
+                'email',
+                'password',
+            ]);
+            (_c = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onError) === null || _c === void 0 ? void 0 : _c.call(sideEffects, err);
+            throw transformedError;
+        }
+    });
+}
+/**
+ * Retrieves a list of calendars belonging to the connected external calendar account.
+ *
+ *
+ * > **Note:**
+ * > Before using this endpoint, establish a connection with an external calendar using [Connect By Credentials](#connect-by-credentials) or [Connect By OAuth](#connect-by-o-auth).
+ * @param connectionId - ID of the external calendar connection to list calendars for.
+ * @public
+ * @documentationMaturity preview
+ * @requiredField connectionId
+ */
+export function listCalendars(connectionId) {
+    var _a, _b, _c;
+    return __awaiter(this, arguments, void 0, function* () {
+        const requestTransformation = { connectionId: '$[0]' };
+        const responseTransformation = '$';
+        // @ts-ignore
+        const { httpClient, sideEffects } = arguments[1];
+        const { toAmbassadorRequest } = serializer({
+            rootSchema: _listCalendarsRequest,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _fromVeloEntity,
+            },
+            customTransformation: requestTransformation,
+        });
+        const { fromJSON } = serializer({
+            rootSchema: _listCalendarsResponse,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _toVeloEntity,
+            },
+            customTransformation: responseTransformation,
+        });
+        const payload = toAmbassadorRequest([connectionId]);
+        const reqOpts = ambassadorWixBookingsCalendarV2ExternalCalendar.listCalendars(payload);
+        __log(`"ListCalendars" sending request with: ${__inspect(reqOpts)}`);
+        (_a = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSiteCall) === null || _a === void 0 ? void 0 : _a.call(sideEffects);
+        try {
+            const result = yield httpClient.request(reqOpts);
+            (_b = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSuccess) === null || _b === void 0 ? void 0 : _b.call(sideEffects, result);
+            return fromJSON(result.data);
+        }
+        catch (err) {
+            const transformedError = transformError(err, requestTransformation, [
+                'connectionId',
+            ]);
+            (_c = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onError) === null || _c === void 0 ? void 0 : _c.call(sideEffects, err);
+            throw transformedError;
+        }
+    });
+}
+/**
+ * Updates the specified external calendar connection's sync configuration.
+ *
+ *
+ * Use Update Sync Config to update a connection's `syncConfig` property.
+ * The `syncConfig` property contains settings for enabling, configuring, or disabling functionality, including:
+ *
+ * + Importing events from one or more specified calendars in the connected external calendar account. If this is enabled, use [List Events](#list-events) to retrieve a list of events from the external calendar.
+ * + Exporting events from the Wix site's calendar to an external calendar.
+ *
+ * To see an external calendar connection's existing sync configuration, use [Get Connection](#get-connection) or [List Connections](#list-connections) and see the `syncConfig` property.
+ *
+ * > **Note:**
+ * > Supported functionality depends on the provider. Use [List Providers](#list-providers) to see details about providers' supported features.
+ * @param connectionId - ID of the external calendar connection to update.
+ * @param syncConfig - Updated sync configuration details.
+ * @public
+ * @documentationMaturity preview
+ * @requiredField connectionId
+ * @requiredField syncConfig
+ */
+export function updateSyncConfig(connectionId, syncConfig, options) {
+    var _a, _b, _c;
+    return __awaiter(this, arguments, void 0, function* () {
+        const requestTransformation = {
+            connectionId: '$[0]',
+            syncConfig: '$[1]',
+            fieldMask: '$[2].fieldMask',
+        };
+        const responseTransformation = '$';
+        // @ts-ignore
+        const { httpClient, sideEffects } = arguments[3];
+        const { toAmbassadorRequest } = serializer({
+            rootSchema: _updateSyncConfigRequest,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _fromVeloEntity,
+            },
+            customTransformation: requestTransformation,
+        });
+        const { fromJSON } = serializer({
+            rootSchema: _updateSyncConfigResponse,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _toVeloEntity,
+            },
+            customTransformation: responseTransformation,
+        });
+        const payload = toAmbassadorRequest([connectionId, syncConfig, options]);
+        const reqOpts = ambassadorWixBookingsCalendarV2ExternalCalendar.updateSyncConfig(payload);
+        __log(`"UpdateSyncConfig" sending request with: ${__inspect(reqOpts)}`);
+        (_a = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSiteCall) === null || _a === void 0 ? void 0 : _a.call(sideEffects);
+        try {
+            const result = yield httpClient.request(reqOpts);
+            (_b = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSuccess) === null || _b === void 0 ? void 0 : _b.call(sideEffects, result);
+            return fromJSON(result.data);
+        }
+        catch (err) {
+            const transformedError = transformError(err, requestTransformation, [
+                'connectionId',
+                'syncConfig',
+                'options',
+            ]);
+            (_c = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onError) === null || _c === void 0 ? void 0 : _c.call(sideEffects, err);
+            throw transformedError;
+        }
+    });
+}
+/**
+ * Disconnects from an external calendar.
+ *
+ *
+ * When an external calendar is disconnected, the external calendar connection's `status` is changed to `DISCONNECTED`.
+ *
+ * After disconnecting, [List Events](#list-events) no longer returns events from the disconnected external calendar.
+ * Exported Wix calendar sessions are deleted from the external calendar.
+ * @param connectionId - ID of the external calendar connection to disconnect.
+ * @public
+ * @documentationMaturity preview
+ * @requiredField connectionId
+ */
+export function disconnect(connectionId) {
+    var _a, _b, _c;
+    return __awaiter(this, arguments, void 0, function* () {
+        const requestTransformation = { connectionId: '$[0]' };
+        const responseTransformation = '$';
+        // @ts-ignore
+        const { httpClient, sideEffects } = arguments[1];
+        const { toAmbassadorRequest } = serializer({
+            rootSchema: _disconnectRequest,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _fromVeloEntity,
+            },
+            customTransformation: requestTransformation,
+        });
+        const { fromJSON } = serializer({
+            rootSchema: _disconnectResponse,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _toVeloEntity,
+            },
+            customTransformation: responseTransformation,
+        });
+        const payload = toAmbassadorRequest([connectionId]);
+        const reqOpts = ambassadorWixBookingsCalendarV2ExternalCalendar.disconnect(payload);
+        __log(`"Disconnect" sending request with: ${__inspect(reqOpts)}`);
+        (_a = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSiteCall) === null || _a === void 0 ? void 0 : _a.call(sideEffects);
+        try {
+            const result = yield httpClient.request(reqOpts);
+            (_b = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSuccess) === null || _b === void 0 ? void 0 : _b.call(sideEffects, result);
+            return fromJSON(result.data);
+        }
+        catch (err) {
+            const transformedError = transformError(err, requestTransformation, [
+                'connectionId',
+            ]);
+            (_c = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onError) === null || _c === void 0 ? void 0 : _c.call(sideEffects, err);
+            throw transformedError;
+        }
+    });
+}
+/**
+ * Retrieves a list of events from all connected external calendars, based on the provided filtering and paging.
+ *
+ *
+ * Use List Events to retrieve an aggregated list of events in the connected external calendars for a specified time range, sorted by start date.
+ *
+ * > **Note:**
+ * > Before using this endpoint, establish a connection with an external calendar using [Connect By Credentials](#connect-by-credentials) or [Connect By OAuth](#connect-by-o-auth).
+ * @public
+ * @documentationMaturity preview
+ */
+export function listEvents(options) {
+    var _a, _b, _c;
+    return __awaiter(this, arguments, void 0, function* () {
+        const requestTransformation = {
+            from: '$[0].from',
+            to: '$[0].to',
+            scheduleIds: '$[0].scheduleIds',
+            userIds: '$[0].userIds',
+            allDay: '$[0].allDay',
+            fieldsets: '$[0].fieldsets',
+            cursorPaging: '$[0].cursorPaging',
+            partialFailure: '$[0].partialFailure',
+        };
+        const responseTransformation = '$';
+        // @ts-ignore
+        const { httpClient, sideEffects } = arguments[1];
+        const { toAmbassadorRequest } = serializer({
+            rootSchema: _listEventsRequest,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _fromVeloEntity,
+            },
+            customTransformation: requestTransformation,
+        });
+        const { fromJSON } = serializer({
+            rootSchema: _listEventsResponse,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _toVeloEntity,
+            },
+            customTransformation: responseTransformation,
+        });
+        const payload = toAmbassadorRequest([options]);
+        const reqOpts = ambassadorWixBookingsCalendarV2ExternalCalendar.listEvents(payload);
+        __log(`"ListEvents" sending request with: ${__inspect(reqOpts)}`);
+        (_a = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSiteCall) === null || _a === void 0 ? void 0 : _a.call(sideEffects);
+        try {
+            const result = yield httpClient.request(reqOpts);
+            (_b = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onSuccess) === null || _b === void 0 ? void 0 : _b.call(sideEffects, result);
+            return fromJSON(result.data);
+        }
+        catch (err) {
+            const transformedError = transformError(err, requestTransformation, [
+                'options',
+            ]);
+            (_c = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onError) === null || _c === void 0 ? void 0 : _c.call(sideEffects, err);
+            throw transformedError;
+        }
+    });
+}
+//# sourceMappingURL=bookings-calendar-v2-external-calendar.universal.js.map