@wix/bookings 1.0.0

package/build/cjs/index.d.ts

@@ -0,0 +1 @@
+export * as availabilityCalendar from './src/bookings-availability-v1-slot-availability.public';

package/build/cjs/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.availabilityCalendar = void 0;
+exports.availabilityCalendar = __importStar(require("./src/bookings-availability-v1-slot-availability.public"));
+//# sourceMappingURL=index.js.map

package/build/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,gHAAgG"}

package/build/cjs/src/bookings-availability-v1-slot-availability.http.d.ts

@@ -0,0 +1,51 @@
+import { RequestOptionsFactory } from '@wix/sdk-types';
+import { QueryAvailabilityRequest, QueryAvailabilityResponse } from './bookings-availability-v1-slot-availability.types';
+/**
+ * Retrieves the availability for sessions
+ * that match the provided query criteria (paging, filtering, and sorting).
+ *
+ *
+ * The Calendar Availability APIs calculate the availability of sessions for
+ * appointments and classes, but not
+ * for courses.
+ *
+ * The entire list of slots is returned in case you want to display both
+ * available and non-available slots in the calendar for your customers.
+ * Using the `bookable` property, you can limit the display to available
+ * slots only.
+ *
+ * When querying, you must enter a start date and an end date. This avoids very large
+ * results that can impact performance.
+ *
+ * #### Calculating availability
+ *
+ * The availability is determined
+ * by checking:
+ * + **The sessions' open slots**. A slot is considered open if the session's
+ * capacity is greater than number of participants.
+ * + **Booking policies**. Policies that affect whether a slot is considered
+ * available include `tooEarlyToBook`, `tooLateToBook`, and `bookOnlineDisabled`.
+ *
+ * Locked sessions do not impact session availability and `bookable` can
+ * be `true` even if `locked` is `true`. For example, if a session has a waitlist and a
+ * place frees up, the slot is offered to the customers on the waitlist, one by one. The
+ * sesssion remains locked because there is still a waitlist, but for a period of time
+ * there is availability, until a customer on the waitlist takes the slot. Locking
+ * prevents customers who are not yet on the waitlist from grabbing the slot.
+ *
+ * #### Handling Daylight Savings Time (DST) for local time zones
+ *
+ * Because of DST, there are cases where certain times either do not exist
+ * or exist twice for a local time zone.
+ * For example, the tine `00:05` on September 5th 2021 might not exist in Santiago, Chile,
+ * because at `00:00` the clock moved
+ * 1 hour forward to `01:00`.
+ *
+ * In this case, the Availability APIs take this
+ * into account and mediate the time gaps automatically. The non-existant local time is
+ * automtically moved forward 1 hour to match local DST. Local times that exist do not change.
+ * So if the `Query Availability` endpoint is called with a `startDate` of `2021-09-05T00:00:01.000`
+ * and an `endDate` of `2021-09-06T00:00:02.000`, `2021-09-05T01:00:01.000` is used in the query
+ * instead. The start time shifts one hour forward and the end time remains the same.
+ */
+export declare function queryAvailability(payload: QueryAvailabilityRequest): RequestOptionsFactory<QueryAvailabilityResponse>;

package/build/cjs/src/bookings-availability-v1-slot-availability.http.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryAvailability = void 0;
+const ambassador_1 = require("@wix/metro-runtime/ambassador");
+const metro_runtime_1 = require("@wix/metro-runtime");
+const _queryAvailabilityRequest = {};
+const _queryAvailabilityResponse = {};
+function resolveComWixpressBookingsAvailabilityAvailabilityCalendarUrl(opts) {
+    const domainToMappings = {
+        'api._api_base_domain_': [
+            {
+                srcPath: '/availability-calendar',
+                destPath: '',
+            },
+        ],
+        _: [
+            {
+                srcPath: '/_api/availability-calendar/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+            {
+                srcPath: '/_api/availability-calendar/v2/availability/schedule',
+                destPath: '/v2/availability/schedule',
+            },
+        ],
+        '*.dev.wix-code.com': [
+            {
+                srcPath: '/_api/availability-calendar/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+        ],
+        'editor._base_domain_': [
+            {
+                srcPath: '/_api/availability-calendar/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+        ],
+        'blocks._base_domain_': [
+            {
+                srcPath: '/_api/availability-calendar/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+        ],
+        'create.editorx': [
+            {
+                srcPath: '/_api/availability-calendar/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+        ],
+        'editor.wixapps.net': [
+            {
+                srcPath: '/_api/availability-calendar/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+        ],
+        'editor-flow.wixapps.net': [
+            {
+                srcPath: '/_api/availability-calendar/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+        ],
+        'www.wixapis.com': [
+            {
+                srcPath: '/availability-calendar/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+            {
+                srcPath: '/bookings/availability-calendar/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+            {
+                srcPath: '/bookings/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+        ],
+        'manage._base_domain_': [
+            {
+                srcPath: '/_api/availability-calendar/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+        ],
+        'www._base_domain_': [
+            {
+                srcPath: '/_api/availability-calendar/v1/availability/query',
+                destPath: '/v1/availability/query',
+            },
+        ],
+    };
+    return metro_runtime_1.resolveUrl(Object.assign(opts, { domainToMappings }));
+}
+/**
+ * Retrieves the availability for sessions
+ * that match the provided query criteria (paging, filtering, and sorting).
+ *
+ *
+ * The Calendar Availability APIs calculate the availability of sessions for
+ * appointments and classes, but not
+ * for courses.
+ *
+ * The entire list of slots is returned in case you want to display both
+ * available and non-available slots in the calendar for your customers.
+ * Using the `bookable` property, you can limit the display to available
+ * slots only.
+ *
+ * When querying, you must enter a start date and an end date. This avoids very large
+ * results that can impact performance.
+ *
+ * #### Calculating availability
+ *
+ * The availability is determined
+ * by checking:
+ * + **The sessions' open slots**. A slot is considered open if the session's
+ * capacity is greater than number of participants.
+ * + **Booking policies**. Policies that affect whether a slot is considered
+ * available include `tooEarlyToBook`, `tooLateToBook`, and `bookOnlineDisabled`.
+ *
+ * Locked sessions do not impact session availability and `bookable` can
+ * be `true` even if `locked` is `true`. For example, if a session has a waitlist and a
+ * place frees up, the slot is offered to the customers on the waitlist, one by one. The
+ * sesssion remains locked because there is still a waitlist, but for a period of time
+ * there is availability, until a customer on the waitlist takes the slot. Locking
+ * prevents customers who are not yet on the waitlist from grabbing the slot.
+ *
+ * #### Handling Daylight Savings Time (DST) for local time zones
+ *
+ * Because of DST, there are cases where certain times either do not exist
+ * or exist twice for a local time zone.
+ * For example, the tine `00:05` on September 5th 2021 might not exist in Santiago, Chile,
+ * because at `00:00` the clock moved
+ * 1 hour forward to `01:00`.
+ *
+ * In this case, the Availability APIs take this
+ * into account and mediate the time gaps automatically. The non-existant local time is
+ * automtically moved forward 1 hour to match local DST. Local times that exist do not change.
+ * So if the `Query Availability` endpoint is called with a `startDate` of `2021-09-05T00:00:01.000`
+ * and an `endDate` of `2021-09-06T00:00:02.000`, `2021-09-05T01:00:01.000` is used in the query
+ * instead. The start time shifts one hour forward and the end time remains the same.
+ */
+function queryAvailability(payload) {
+    const { toJSON: toReq, fromJSON: fromReq } = ambassador_1.serializer(_queryAvailabilityRequest, {});
+    const { fromJSON: fromRes } = ambassador_1.serializer(_queryAvailabilityResponse, {});
+    function __queryAvailability({ host }) {
+        const serializedData = toReq(payload);
+        const metadata = {
+            method: 'POST',
+            url: resolveComWixpressBookingsAvailabilityAvailabilityCalendarUrl({
+                protoPath: '/v1/availability/query',
+                data: serializedData,
+                host,
+            }),
+            data: serializedData,
+            transformResponse: fromRes,
+        };
+        return metadata;
+    }
+    __queryAvailability.fromReq = fromReq;
+    return __queryAvailability;
+}
+exports.queryAvailability = queryAvailability;
+//# sourceMappingURL=bookings-availability-v1-slot-availability.http.js.map

package/build/cjs/src/bookings-availability-v1-slot-availability.http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bookings-availability-v1-slot-availability.http.js","sourceRoot":"","sources":["../../../src/bookings-availability-v1-slot-availability.http.ts"],"names":[],"mappings":";;;AAAA,8DAA2D;AAC3D,sDAAgD;AAQhD,MAAM,yBAAyB,GAAG,EAAE,CAAC;AACrC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAEtC,SAAS,6DAA6D,CACpE,IAA8C;IAE9C,MAAM,gBAAgB,GAAG;QACvB,uBAAuB,EAAE;YACvB;gBACE,OAAO,EAAE,wBAAwB;gBACjC,QAAQ,EAAE,EAAE;aACb;SACF;QACD,CAAC,EAAE;YACD;gBACE,OAAO,EAAE,mDAAmD;gBAC5D,QAAQ,EAAE,wBAAwB;aACnC;YACD;gBACE,OAAO,EAAE,sDAAsD;gBAC/D,QAAQ,EAAE,2BAA2B;aACtC;SACF;QACD,oBAAoB,EAAE;YACpB;gBACE,OAAO,EAAE,mDAAmD;gBAC5D,QAAQ,EAAE,wBAAwB;aACnC;SACF;QACD,sBAAsB,EAAE;YACtB;gBACE,OAAO,EAAE,mDAAmD;gBAC5D,QAAQ,EAAE,wBAAwB;aACnC;SACF;QACD,sBAAsB,EAAE;YACtB;gBACE,OAAO,EAAE,mDAAmD;gBAC5D,QAAQ,EAAE,wBAAwB;aACnC;SACF;QACD,gBAAgB,EAAE;YAChB;gBACE,OAAO,EAAE,mDAAmD;gBAC5D,QAAQ,EAAE,wBAAwB;aACnC;SACF;QACD,oBAAoB,EAAE;YACpB;gBACE,OAAO,EAAE,mDAAmD;gBAC5D,QAAQ,EAAE,wBAAwB;aACnC;SACF;QACD,yBAAyB,EAAE;YACzB;gBACE,OAAO,EAAE,mDAAmD;gBAC5D,QAAQ,EAAE,wBAAwB;aACnC;SACF;QACD,iBAAiB,EAAE;YACjB;gBACE,OAAO,EAAE,8CAA8C;gBACvD,QAAQ,EAAE,wBAAwB;aACnC;YACD;gBACE,OAAO,EAAE,uDAAuD;gBAChE,QAAQ,EAAE,wBAAwB;aACnC;YACD;gBACE,OAAO,EAAE,iCAAiC;gBAC1C,QAAQ,EAAE,wBAAwB;aACnC;SACF;QACD,sBAAsB,EAAE;YACtB;gBACE,OAAO,EAAE,mDAAmD;gBAC5D,QAAQ,EAAE,wBAAwB;aACnC;SACF;QACD,mBAAmB,EAAE;YACnB;gBACE,OAAO,EAAE,mDAAmD;gBAC5D,QAAQ,EAAE,wBAAwB;aACnC;SACF;KACF,CAAC;IAEF,OAAO,0BAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,SAAgB,iBAAiB,CAC/B,OAAiC;IAEjC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,uBAAU,CACrD,yBAAyB,EACzB,EAAE,CACH,CAAC;IACF,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,uBAAU,CAAC,0BAA0B,EAAE,EAAE,CAAC,CAAC;IAEzE,SAAS,mBAAmB,CAAC,EAAE,IAAI,EAAO;QACxC,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QACtC,MAAM,QAAQ,GAAG;YACf,MAAM,EAAE,MAAa;YACrB,GAAG,EAAE,6DAA6D,CAAC;gBACjE,SAAS,EAAE,wBAAwB;gBACnC,IAAI,EAAE,cAAc;gBACpB,IAAI;aACL,CAAC;YACF,IAAI,EAAE,cAAc;YACpB,iBAAiB,EAAE,OAAO;SAC3B,CAAC;QAEF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,mBAAmB,CAAC,OAAO,GAAG,OAAO,CAAC;IAEtC,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AA5BD,8CA4BC"}

package/build/cjs/src/bookings-availability-v1-slot-availability.public.d.ts

@@ -0,0 +1,5 @@
+import { HttpClient } from '@wix/sdk-types';
+import { QueryAvailabilityOptions, QueryV2 } from './bookings-availability-v1-slot-availability.universal';
+export declare function queryAvailability(httpClient: HttpClient): (query: QueryV2, options?: QueryAvailabilityOptions | undefined) => Promise<import("./bookings-availability-v1-slot-availability.universal").QueryAvailabilityResponse>;
+export { LocationType, SortOrder, } from './bookings-availability-v1-slot-availability.universal';
+export { SlotAvailability, Slot, SlotResource, Location, WaitingList, BookingPolicyViolations, QueryAvailabilityRequest, QueryV2, QueryV2PagingMethodOneOf, Sorting, CursorPaging, QueryAvailabilityResponse, PagingMetadataV2, Cursors, GetSlotAvailabilityRequest, GetSlotAvailabilityResponse, BookingPolicySettings, GetScheduleAvailabilityRequest, GetScheduleAvailabilityResponse, ScheduleAvailability, QueryAvailabilityOptions, } from './bookings-availability-v1-slot-availability.universal';

package/build/cjs/src/bookings-availability-v1-slot-availability.public.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortOrder = exports.LocationType = exports.queryAvailability = void 0;
+const bookings_availability_v1_slot_availability_universal_1 = require("./bookings-availability-v1-slot-availability.universal");
+function queryAvailability(httpClient) {
+    return (query, options) => bookings_availability_v1_slot_availability_universal_1.queryAvailability(query, options, 
+    // @ts-ignore
+    { httpClient });
+}
+exports.queryAvailability = queryAvailability;
+var bookings_availability_v1_slot_availability_universal_2 = require("./bookings-availability-v1-slot-availability.universal");
+Object.defineProperty(exports, "LocationType", { enumerable: true, get: function () { return bookings_availability_v1_slot_availability_universal_2.LocationType; } });
+Object.defineProperty(exports, "SortOrder", { enumerable: true, get: function () { return bookings_availability_v1_slot_availability_universal_2.SortOrder; } });
+//# sourceMappingURL=bookings-availability-v1-slot-availability.public.js.map

package/build/cjs/src/bookings-availability-v1-slot-availability.public.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bookings-availability-v1-slot-availability.public.js","sourceRoot":"","sources":["../../../src/bookings-availability-v1-slot-availability.public.ts"],"names":[],"mappings":";;;AACA,iIAIgE;AAEhE,SAAgB,iBAAiB,CAAC,UAAsB;IACtD,OAAO,CAAC,KAAc,EAAE,OAAkC,EAAE,EAAE,CAC5D,wEAA0B,CACxB,KAAK,EACL,OAAO;IACP,aAAa;IACb,EAAE,UAAU,EAAE,CACf,CAAC;AACN,CAAC;AARD,8CAQC;AAED,+HAGgE;AAF9D,oJAAA,YAAY,OAAA;AACZ,iJAAA,SAAS,OAAA"}

package/build/cjs/src/bookings-availability-v1-slot-availability.types.d.ts

@@ -0,0 +1,260 @@
+export interface SlotAvailability {
+    /**
+     * The slot for the corresponding session, when the session is either a single session
+     * or a specific session generated from a recurring session.
+     */
+    slot?: Slot;
+    /**
+     * Whether the slot is bookable. Bookability is determined by checking a
+     * session's open slots and booking policies. Locks are not taken into
+     * account.
+     */
+    bookable?: boolean;
+    /**
+     * Total number of spots for this slot.
+     * For example, if a session has a total of 10 spots and 3 spots are booked,
+     * `spotsTotal` is 10 and `openSpots` is 7.
+     */
+    totalSpots?: number | null;
+    /** Number of open spots for this slot. */
+    openSpots?: number | null;
+    /** An object describing the slot's waitlist and its occupancy. */
+    waitingList?: WaitingList;
+    /** Booking policy violations for the slot. */
+    bookingPolicyViolations?: BookingPolicyViolations;
+    /**
+     * Indicates whether the slot is locked because a waitlist exists.
+     * When a slot frees up, the slot is offered to the next customer on the waitlist. Read-only.
+     */
+    locked?: boolean | null;
+}
+export interface Slot {
+    /**
+     * ID for the slot's corresponding session, when the session is either a single session
+     * or a specific session generated from a recurring session.
+     */
+    sessionId?: string | null;
+    /** Service ID. */
+    serviceId?: string;
+    /** Schedule ID. */
+    scheduleId?: string;
+    /**
+     * The start time of this slot in [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339)
+     * format.
+     *
+     * If `timezone` is specified,
+     * dates are based on the local date/time. This means that the timezone offset
+     * in the `start_date` is ignored.
+     */
+    startDate?: string | null;
+    /**
+     * The end time of this slot in
+     * [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339) format.
+     *
+     * If `timezone` is specified,
+     * dates are based on the local date/time. This means that the timezone offset
+     * in the `end_date` is ignored.
+     */
+    endDate?: string | null;
+    /**
+     * The timezone for which slot availability is to be calculated.
+     *
+     * Learn more about [handling Daylight Savings Time (DST) for local time zones](https://dev.wix.com/api/rest/wix-bookings/availability-calendar/query-availability#wix-bookings_availability-calendar_query-availability_handling-daylight-savings-time-dst-for-local-time-zones)
+     * when calculating availability.
+     */
+    timezone?: string | null;
+    /**
+     * The resource required for this slot. Currently, the only supported resource
+     * is the relevant staff member for the slot.
+     */
+    resource?: SlotResource;
+    /** Geographic location of the slot. */
+    location?: Location;
+}
+export interface SlotResource {
+    /**
+     * Resource ID.
+     * @readonly
+     */
+    id?: string | null;
+    /** Resource name. Read only. */
+    name?: string | null;
+}
+export interface Location {
+    /**
+     * Business location ID. Available only for locations that are business locations,
+     * meaning the `location_type` is `"OWNER_BUSINESS"`.
+     */
+    id?: string | null;
+    /** Location name. */
+    name?: string | null;
+    /** The full address of this location. */
+    formattedAddress?: string | null;
+    /**
+     * Location type.
+     *
+     * - `"OWNER_BUSINESS"`: The business address, as set in the site’s general settings.
+     * - `"OWNER_CUSTOM"`: The address as set when creating the service.
+     * - `"CUSTOM"`: The address as set for the individual session.
+     */
+    locationType?: LocationType;
+}
+export declare enum LocationType {
+    UNDEFINED = "UNDEFINED",
+    OWNER_BUSINESS = "OWNER_BUSINESS",
+    OWNER_CUSTOM = "OWNER_CUSTOM",
+    CUSTOM = "CUSTOM"
+}
+export interface WaitingList {
+    /**
+     * Total number of spots and open spots for this waitlist.
+     * For example, a Yoga class with 10 waitlist spots and 3 registered
+     * on the waitlist has 10 `total_spots` and 7 `open_spots`.
+     */
+    totalSpots?: number | null;
+    /** Number of open spots for this waitlist. */
+    openSpots?: number | null;
+}
+export interface BookingPolicyViolations {
+    /** Bookings policy violation. Too early to book this slot. */
+    tooEarlyToBook?: boolean | null;
+    /** Bookings policy violation. Too late to book this slot. */
+    tooLateToBook?: boolean | null;
+    /** Bookings policy violation. Online booking is disabled for this slot. */
+    bookOnlineDisabled?: boolean | null;
+}
+export interface QueryAvailabilityRequest {
+    /** Query options. */
+    query: QueryV2;
+    /**
+     * The timezone for which session availability is to be calculated. If specified,
+     * dates are based on the local date/time, meaning that the timezone offset
+     * in the date's format is ignored.
+     *
+     * Learn more about [handling Daylight Savings Time (DST) for local time zones](https://dev.wix.com/api/rest/wix-bookings/availability-calendar/query-availability#wix-bookings_availability-calendar_query-availability_handling-daylight-savings-time-dst-for-local-time-zones)
+     * when calculating availability.
+     */
+    timezone?: string | null;
+    /**
+     * Maximum number of slots to load for each date. For example, if `slots_per_day` is set to `3`,
+     * at most 3 available slots are returned for each day in the date range specified in the query's
+     * `filter`.
+     *
+     * When a day has both bookable and non-bookable slots, bookable slots are returned first.
+     * Non-bookable slots are returned according to the specified filters, after all
+     * bookable slots are already included.
+     */
+    slotsPerDay?: number | null;
+}
+export interface QueryV2 extends QueryV2PagingMethodOneOf {
+    /**
+     * Filter object. For a list of
+     * fields you can filter by, see [Calendar Availability: Supported Fields, Filters, and Sorting](https://dev.wix.com/api/rest/wix-bookings/availability-calendar/supported-fields,-filters,-and-sorting).
+     * You must include the `startDate` and `endDate` in the filter. This avoids large results that can impact performance.
+     */
+    filter?: Record<string, any> | null;
+    /**
+     * Sort options.
+     * Currently, only sorting by `startDate` is supported. For details
+     * on sorting, see [Calendar Availability: Supported Fields, Filters and Sorting](https://dev.wix.com/api/rest/wix-bookings/availability-calendar/supported-fields,-filters,-and-sorting).
+     */
+    sort?: Sorting[];
+    /** List of projected fields to return. All fields are supported. */
+    fields?: string[];
+    /** Cursor token pointing to a page of results. Not used in the first request. Following requests use the cursor token and not `filter` or `sort`. */
+    cursorPaging?: CursorPaging;
+}
+/** @oneof */
+export interface QueryV2PagingMethodOneOf {
+    /** Cursor token pointing to a page of results. Not used in the first request. Following requests use the cursor token and not `filter` or `sort`. */
+    cursorPaging?: CursorPaging;
+}
+export interface Sorting {
+    /** Name of the field to sort by. */
+    fieldName?: string;
+    /** Sort order. */
+    order?: SortOrder;
+}
+export declare enum SortOrder {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+export interface CursorPaging {
+    /** Number of items to load. */
+    limit?: number | null;
+    /**
+     * Pointer to the next or previous page in the list of results.
+     *
+     * You can get the relevant cursor token
+     * from the `pagingMetadata` object in the previous call's response.
+     * Not relevant for the first request.
+     */
+    cursor?: string | null;
+}
+export interface QueryAvailabilityResponse {
+    /** List of slots that potentially can be booked. */
+    availabilityEntries?: SlotAvailability[];
+    /** Details on the paged set of returned results. */
+    pagingMetadata?: PagingMetadataV2;
+}
+export interface PagingMetadataV2 {
+    /** Number of items returned in the response. */
+    count?: number | null;
+    /** Offset that was requested. */
+    offset?: number | null;
+    /** Total number of items that match the query. Returned if offset paging is used and the `tooManyToCount` flag is not set. */
+    total?: number | null;
+    /** Flag that indicates the server failed to calculate the `total` field. */
+    tooManyToCount?: boolean | null;
+    /** Cursors to navigate through the result pages using `next` and `prev`. Returned if cursor paging is used. */
+    cursors?: Cursors;
+}
+export interface Cursors {
+    /** Cursor pointing to next page in the list of results. */
+    next?: string | null;
+    /** Cursor pointing to previous page in the list of results. */
+    prev?: string | null;
+}
+export interface GetSlotAvailabilityRequest {
+    /** The slot for which the availability is checked. */
+    slot?: Slot;
+    /**
+     * The timezone for which slot availability is to be calculated. If specified,
+     * dates are based on the local date/time, meaning that the timezone offset
+     * in the date's format is ignored.
+     *
+     * Learn more about [handling Daylight Savings Time (DST) for local time zones](https://dev.wix.com/api/rest/wix-bookings/availability-calendar/query-availability#wix-bookings_availability-calendar_query-availability_handling-daylight-savings-time-dst-for-local-time-zones)
+     * when calculating availability.
+     */
+    timezone?: string | null;
+}
+export interface GetSlotAvailabilityResponse {
+    availability?: SlotAvailability;
+    bookingPolicySettings?: BookingPolicySettings;
+}
+export interface BookingPolicySettings {
+    /**
+     * The policy defining the maximum number of participants that can
+     * be booked for a slot or a schedule.
+     */
+    maxParticipantsPerBooking?: number | null;
+}
+export interface GetScheduleAvailabilityRequest {
+    /** The schedule ID for which availability is being checked. */
+    scheduleId?: string;
+}
+export interface GetScheduleAvailabilityResponse {
+    availability?: ScheduleAvailability;
+    bookingPolicySettings?: BookingPolicySettings;
+}
+export interface ScheduleAvailability {
+    /**
+     * The total number of spots defined for the schedule, including
+     * both open and non-available spots.
+     */
+    totalSpots?: number | null;
+    /** The number of open spots defined for the schedule. */
+    openSpots?: number | null;
+    /** Booking policy violations for the schedule. */
+    bookingPolicyViolations?: BookingPolicyViolations;
+}

package/build/cjs/src/bookings-availability-v1-slot-availability.types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortOrder = exports.LocationType = void 0;
+var LocationType;
+(function (LocationType) {
+    LocationType["UNDEFINED"] = "UNDEFINED";
+    LocationType["OWNER_BUSINESS"] = "OWNER_BUSINESS";
+    LocationType["OWNER_CUSTOM"] = "OWNER_CUSTOM";
+    LocationType["CUSTOM"] = "CUSTOM";
+})(LocationType = exports.LocationType || (exports.LocationType = {}));
+var SortOrder;
+(function (SortOrder) {
+    SortOrder["ASC"] = "ASC";
+    SortOrder["DESC"] = "DESC";
+})(SortOrder = exports.SortOrder || (exports.SortOrder = {}));
+//# sourceMappingURL=bookings-availability-v1-slot-availability.types.js.map

package/build/cjs/src/bookings-availability-v1-slot-availability.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bookings-availability-v1-slot-availability.types.js","sourceRoot":"","sources":["../../../src/bookings-availability-v1-slot-availability.types.ts"],"names":[],"mappings":";;;AAyGA,IAAY,YAKX;AALD,WAAY,YAAY;IACtB,uCAAuB,CAAA;IACvB,iDAAiC,CAAA;IACjC,6CAA6B,CAAA;IAC7B,iCAAiB,CAAA;AACnB,CAAC,EALW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAKvB;AA8ED,IAAY,SAGX;AAHD,WAAY,SAAS;IACnB,wBAAW,CAAA;IACX,0BAAa,CAAA;AACf,CAAC,EAHW,SAAS,GAAT,iBAAS,KAAT,iBAAS,QAGpB"}