@wix/bookings 1.0.0

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

@@ -0,0 +1,341 @@
+export declare const __debug: {
+    verboseLogging: {
+        on: () => boolean;
+        off: () => boolean;
+    };
+};
+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;
+}
+/**
+ * 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.
+ * @param query - Query options.
+ * @public
+ * @documentationMaturity preview
+ * @requiredField query
+ * @requiredField query.filter
+ */
+export declare function queryAvailability(query: QueryV2, options?: QueryAvailabilityOptions): Promise<QueryAvailabilityResponse>;
+export interface QueryAvailabilityOptions {
+    /**
+     * 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;
+}

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

@@ -0,0 +1,165 @@
+"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;
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryAvailability = exports.SortOrder = exports.LocationType = exports.__debug = void 0;
+const velo_1 = require("@wix/metro-runtime/velo");
+const ambassadorWixBookingsAvailabilityV1SlotAvailability = __importStar(require("./bookings-availability-v1-slot-availability.http"));
+let __verbose = false;
+function __log(...args) {
+    __verbose && console.log(...args);
+}
+function __inspect(obj) {
+    return obj;
+}
+exports.__debug = {
+    verboseLogging: {
+        on: () => (__verbose = true),
+        off: () => (__verbose = false),
+    },
+};
+const _toVeloEntity = '$';
+const _fromVeloEntity = '$';
+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 = {}));
+const _queryAvailabilityRequest = {};
+const _queryAvailabilityResponse = {};
+/**
+ * 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.
+ * @param query - Query options.
+ * @public
+ * @documentationMaturity preview
+ * @requiredField query
+ * @requiredField query.filter
+ */
+function queryAvailability(query, options) {
+    var _a, _b, _c;
+    return __awaiter(this, arguments, void 0, function* () {
+        const requestTransformation = {
+            query: '$[0]',
+            timezone: '$[1].timezone',
+            slotsPerDay: '$[1].slotsPerDay',
+        };
+        const responseTransformation = '$';
+        // @ts-ignore
+        const { httpClient, sideEffects } = arguments[2];
+        const { toAmbassadorRequest } = velo_1.serializer({
+            rootSchema: _queryAvailabilityRequest,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [],
+                transformation: _fromVeloEntity,
+            },
+            customTransformation: requestTransformation,
+        });
+        const { fromJSON } = velo_1.serializer({
+            rootSchema: _queryAvailabilityResponse,
+            depSchemas: {},
+            fqdnTransformation: {
+                paths: [...['Array#availabilityEntries']],
+                transformation: _toVeloEntity,
+            },
+            customTransformation: responseTransformation,
+        });
+        const payload = toAmbassadorRequest([query, options]);
+        const reqOpts = ambassadorWixBookingsAvailabilityV1SlotAvailability.queryAvailability(payload);
+        __log(`"QueryAvailability" 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 = velo_1.transformError(err, requestTransformation, [
+                'query',
+                'options',
+            ]);
+            (_c = sideEffects === null || sideEffects === void 0 ? void 0 : sideEffects.onError) === null || _c === void 0 ? void 0 : _c.call(sideEffects, err);
+            throw transformedError;
+        }
+    });
+}
+exports.queryAvailability = queryAvailability;
+//# sourceMappingURL=bookings-availability-v1-slot-availability.universal.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bookings-availability-v1-slot-availability.universal.js","sourceRoot":"","sources":["../../../src/bookings-availability-v1-slot-availability.universal.ts"],"names":[],"mappings":"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"}

package/build/es/index.d.ts

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

package/build/es/index.js

@@ -0,0 +1,2 @@
+export * as availabilityCalendar from './src/bookings-availability-v1-slot-availability.public';
+//# sourceMappingURL=index.js.map

package/build/es/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,oBAAoB,MAAM,yDAAyD,CAAC"}

package/build/es/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>;