@wix/bookings 1.0.419 → 1.0.421

package/type-bundles/context.bundle.d.ts

@@ -129,18 +129,18 @@ interface QueryV2 extends QueryV2PagingMethodOneOf {
      */
     filter?: Record<string, any> | null;
     /** Currently, only sorting by `startDate` is supported.  */
-    sort?: Sorting$1[];
+    sort?: Sorting$2[];
 }
 /** @oneof */
 interface QueryV2PagingMethodOneOf {
 }
-interface Sorting$1 {
+interface Sorting$2 {
     /** Name of the field to sort by. */
     fieldName?: string;
     /** Sort order. */
-    order?: SortOrder$1;
+    order?: SortOrder$2;
 }
-declare enum SortOrder$1 {
+declare enum SortOrder$2 {
     ASC = "ASC",
     DESC = "DESC"
 }
@@ -392,7 +392,7 @@ interface NestedTimeSlot$1 {
      */
     availableResources?: AvailableResources$1[];
 }
-interface CursorPaging$3 {
+interface CursorPaging$4 {
     /**
      * Number of results to load.
      *
@@ -409,9 +409,9 @@ interface CursorPaging$3 {
      */
     cursor?: string | null;
 }
-interface CursorPagingMetadata$2 {
+interface CursorPagingMetadata$3 {
     /** Offset that was requested. */
-    cursors?: Cursors$5;
+    cursors?: Cursors$6;
     /**
      * Indicates if there are more results after the current page.
      * If `true`, another page of results can be retrieved.
@@ -419,7 +419,7 @@ interface CursorPagingMetadata$2 {
      */
     hasNext?: boolean | null;
 }
-interface Cursors$5 {
+interface Cursors$6 {
     /** Cursor pointing to next page in the list of results. */
     next?: string | null;
     /** Cursor pointing to previous page in the list of results. */
@@ -455,7 +455,7 @@ interface ListAvailabilityTimeSlotsResponse {
      * <code class="grey-background">count</code> is not supported.</p>
      * </blockquote>
      */
-    cursorPagingMetadata?: CursorPagingMetadata$2;
+    cursorPagingMetadata?: CursorPagingMetadata$3;
 }
 interface GetAvailabilityTimeSlotResponse {
     /** Time slot. */
@@ -630,7 +630,7 @@ interface ListAvailabilityTimeSlotsOptions {
      * </p>
      * </blockquote>
      */
-    cursorPaging?: CursorPaging$3;
+    cursorPaging?: CursorPaging$4;
     /**
      * resources filter
      * If specified, only time slots with these resources will be returned.
@@ -843,7 +843,7 @@ interface Service$1 {
      */
     includeResourceTypeIds?: string[];
 }
-interface CursorPaging$2 {
+interface CursorPaging$3 {
     /**
      * Number of results to load.
      *
@@ -881,11 +881,11 @@ interface ListMultiServiceAvailabilityTimeSlotsResponse {
      * <code class="grey-background">count</code> is not supported.</p>
      * </blockquote>
      */
-    cursorPagingMetadata?: CursorPagingMetadata$1;
+    cursorPagingMetadata?: CursorPagingMetadata$2;
 }
-interface CursorPagingMetadata$1 {
+interface CursorPagingMetadata$2 {
     /** Offset that was requested. */
-    cursors?: Cursors$4;
+    cursors?: Cursors$5;
     /**
      * Indicates if there are more results after the current page.
      * If `true`, another page of results can be retrieved.
@@ -893,7 +893,7 @@ interface CursorPagingMetadata$1 {
      */
     hasNext?: boolean | null;
 }
-interface Cursors$4 {
+interface Cursors$5 {
     /** Cursor pointing to next page in the list of results. */
     next?: string | null;
     /** Cursor pointing to previous page in the list of results. */
@@ -1061,7 +1061,7 @@ interface ListMultiServiceAvailabilityTimeSlotsOptions {
      * </p>
      * </blockquote>
      */
-    cursorPaging?: CursorPaging$2;
+    cursorPaging?: CursorPaging$3;
 }
 
 declare function listMultiServiceAvailabilityTimeSlots$1(httpClient: HttpClient): (options?: ListMultiServiceAvailabilityTimeSlotsOptions) => Promise<ListMultiServiceAvailabilityTimeSlotsResponse & ListMultiServiceAvailabilityTimeSlotsResponseNonNullableFields>;
@@ -1343,7 +1343,7 @@ interface DisconnectResponse {
     /** Updated connection details. */
     connection?: Connection;
 }
-interface CursorPaging$1 {
+interface CursorPaging$2 {
     /**
      * Number of events to load.
      * Max: `1000`
@@ -1362,7 +1362,7 @@ interface ListEventsResponse {
     /** List of external calendar events matching the filters. */
     events?: Event$2[];
     /** Paging metadata. */
-    pagingMetadata?: CursorPagingMetadata;
+    pagingMetadata?: CursorPagingMetadata$1;
     /** List of provider IDs for connections for which retrieval of events failed. Returned only if `partialFailure` parameter is `true` in the request. */
     failedProviderIds?: string[] | null;
 }
@@ -1400,11 +1400,11 @@ interface Event$2 {
      */
     scheduleOwnerName?: string | null;
 }
-interface CursorPagingMetadata {
+interface CursorPagingMetadata$1 {
     /** Number of items returned in the response. */
     count?: number | null;
     /** Offset that was requested. */
-    cursors?: Cursors$3;
+    cursors?: Cursors$4;
     /**
      * Indicates if there are more results after the current page.
      * If `true`, another page of results can be retrieved.
@@ -1412,7 +1412,7 @@ interface CursorPagingMetadata {
      */
     hasNext?: boolean | null;
 }
-interface Cursors$3 {
+interface Cursors$4 {
     /** Cursor pointing to next page in the list of results. */
     next?: string | null;
 }
@@ -1562,7 +1562,7 @@ interface ListEventsOptions {
      */
     fieldsets?: string[];
     /** Pagination options. */
-    cursorPaging?: CursorPaging$1;
+    cursorPaging?: CursorPaging$2;
     /**
      * Whether to return a partial list of events if details can't be retrieved for some connections.
      *
@@ -2597,7 +2597,7 @@ interface GetServiceOptionsAndVariantsByServiceIdResponse {
     /** Retrieved `serviceOptionsAndVariants` object. */
     serviceVariants?: ServiceOptionsAndVariants;
 }
-interface Cursors$2 {
+interface Cursors$3 {
     /** Cursor string pointing to the next page in the list of results. */
     next?: string | null;
     /** Cursor pointing to the previous page in the list of results. */
@@ -2796,7 +2796,7 @@ interface DeleteServiceOptionsAndVariantsOptions {
     revision?: string;
 }
 interface QueryCursorResult$1 {
-    cursors: Cursors$2;
+    cursors: Cursors$3;
     hasNext: () => boolean;
     hasPrev: () => boolean;
     length: number;
@@ -2823,7 +2823,7 @@ interface ServiceOptionsAndVariantsListQueryBuilder {
      * @param values - List of values to compare against.
      * @documentationMaturity preview
      */
-    hasSome: (propertyName: 'variants.values.choices.optionId' | 'variants.values.price', value: any[]) => ServiceOptionsAndVariantsListQueryBuilder;
+    hasSome: (propertyName: 'options.values.id' | 'options.values.type' | 'variants.values.choices.custom' | 'variants.values.choices.optionId' | 'variants.values.price.value' | 'variants.values.price.currency', value: any[]) => ServiceOptionsAndVariantsListQueryBuilder;
     /**
      * Refines a query to match items where the specified property is in a short list of specified values.
      * @documentationMaturity preview */
@@ -3478,17 +3478,17 @@ interface Attendance$1 {
     /** Total number of participants that attended the session. */
     numberOfAttendees?: number;
 }
-interface Sorting {
+interface Sorting$1 {
     /** Name of the field to sort by. */
     fieldName?: string;
     /** Sort order. */
-    order?: SortOrder;
+    order?: SortOrder$1;
 }
-declare enum SortOrder {
+declare enum SortOrder$1 {
     ASC = "ASC",
     DESC = "DESC"
 }
-interface CursorPaging {
+interface CursorPaging$1 {
     /** Maximum number of items to return in the results. */
     limit?: number | null;
     /**
@@ -3509,9 +3509,9 @@ interface PagingMetadataV2 {
     /** 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$1;
+    cursors?: Cursors$2;
 }
-interface Cursors$1 {
+interface Cursors$2 {
     /** Cursor string pointing to the next page in the list of results. */
     next?: string | null;
     /** Cursor pointing to the previous page in the list of results. */
@@ -3521,7 +3521,7 @@ interface CommonQueryV2 extends CommonQueryV2PagingMethodOneOf {
     /** Paging options to limit and skip the number of items. */
     paging?: CommonPaging;
     /** 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;
+    cursorPaging?: CursorPaging$1;
     /**
      * Filter object in the following format:
      * `"filter" : {
@@ -3538,14 +3538,14 @@ interface CommonQueryV2 extends CommonQueryV2PagingMethodOneOf {
      * Sort object in the following format:
      * `[{"fieldName":"sortField1","order":"ASC"},{"fieldName":"sortField2","order":"DESC"}]`
      */
-    sort?: Sorting[];
+    sort?: Sorting$1[];
 }
 /** @oneof */
 interface CommonQueryV2PagingMethodOneOf {
     /** Paging options to limit and skip the number of items. */
     paging?: CommonPaging;
     /** 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;
+    cursorPaging?: CursorPaging$1;
 }
 interface CommonPaging {
     /** Number of items to load. */
@@ -4511,6 +4511,48 @@ declare enum WebhookIdentityType$2 {
     WIX_USER = "WIX_USER",
     APP = "APP"
 }
+interface BulkServiceResult {
+    /** Updated service metadata. */
+    itemMetadata?: ItemMetadata$1;
+    /** The updated service. */
+    item?: Service;
+}
+interface ItemMetadata$1 {
+    /** Item ID. Should always be available, unless it's impossible (for example, when failing to create an item). */
+    _id?: string | null;
+    /** Index of the item within the request array. Allows for correlation between request and response items. */
+    originalIndex?: number;
+    /** Whether the requested action was successful for this item. When `false`, the `error` field is populated. */
+    success?: boolean;
+    /** Details about the error in case of failure. */
+    error?: ApplicationError$1;
+}
+interface ApplicationError$1 {
+    /** Error code. */
+    code?: string;
+    /** Description of the error. */
+    description?: string;
+    /** Data related to the error. */
+    data?: Record<string, any> | null;
+}
+interface BulkActionMetadata$1 {
+    /** Number of items that were successfully processed. */
+    totalSuccesses?: number;
+    /** Number of items that couldn't be processed. */
+    totalFailures?: number;
+    /** Number of failures without details because detailed failure threshold was exceeded. */
+    undetailedFailures?: number;
+}
+interface MaskedService {
+    /** Service to update. [Partial updates](https://dev.wix.com/api/rest/wix-bookings/bookings/patch-endpoints-and-field-masks-in-update-requests) are supported. */
+    service?: Service;
+}
+interface BulkUpdateServicesResponse {
+    /** The result of each service update. */
+    results?: BulkServiceResult[];
+    /** Update statistics. */
+    bulkActionMetadata?: BulkActionMetadata$1;
+}
 interface V2ParticipantNotification {
     /**
      * Whether to send the message about the changes to the customer.
@@ -4521,111 +4563,2095 @@ interface V2ParticipantNotification {
     /** Custom message to send to the participants about the changes to the booking. */
     message?: string | null;
 }
-interface CountServicesResponse {
-    /** The number of services matching the given filter. */
-    count?: number;
+interface BulkDeleteServicesResponse {
+    /** The result of each service removal. */
+    results?: BulkServiceResult[];
+    /** Update statistics. */
+    bulkActionMetadata?: BulkActionMetadata$1;
 }
-interface CountServicesResponseNonNullableFields {
-    count: number;
+interface Sorting {
+    /** Name of the field to sort by. */
+    fieldName?: string;
+    /** Sort order. */
+    order?: SortOrder;
 }
-interface BaseEventMetadata$2 {
-    /** App instance ID. */
-    instanceId?: string | null;
-    /** Event type. */
-    eventType?: string;
-    /** The identification type and identity data. */
-    identity?: IdentificationData$3;
+declare enum SortOrder {
+    ASC = "ASC",
+    DESC = "DESC"
 }
-interface EventMetadata$1 extends BaseEventMetadata$2 {
+interface CursorPaging {
+    /** Number of items to load. */
+    limit?: number | null;
     /**
-     * Unique event ID.
-     * Allows clients to ignore duplicate webhooks.
+     * 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.
      */
-    _id?: string;
+    cursor?: string | null;
+}
+interface Cursors$1 {
+    /** 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;
+}
+interface CursorSearch extends CursorSearchPagingMethodOneOf {
     /**
-     * Assumes actions are also always typed to an entity_type
-     * Example: wix.stores.catalog.product, wix.bookings.session, wix.payments.transaction
+     * Cursor pointing to page of results.
+     * When requesting 'cursor_paging.cursor', no `filter`, `sort` or `search` can be provided.
      */
-    entityFqdn?: string;
+    cursorPaging?: CursorPaging;
+    /** A filter object. See documentation [here](https://bo.wix.com/wix-docs/rnd/platformization-guidelines/api-query-language#platformization-guidelines_api-query-language_defining-in-protobuf) */
+    filter?: Record<string, any> | null;
+    /** Sort object in the form [{"fieldName":"sortField1"},{"fieldName":"sortField2","direction":"DESC"}] */
+    sort?: Sorting[];
+    /** Aggregations | Faceted search: refers to a way to explore large amounts of data by displaying summaries about various partitions of the data and later allowing to narrow the navigation to a specific partition. */
+    aggregations?: Aggregation[];
+    /** Free text to match in searchable fields */
+    search?: SearchDetails;
     /**
-     * This is top level to ease client code dispatching of messages (switch on entity_fqdn+slug)
-     * This is although the created/updated/deleted notion is duplication of the oneof types
-     * Example: created/updated/deleted/started/completed/email_opened
+     * UTC offset or IANA time zone. Valid values are
+     * ISO 8601 UTC offsets, such as +02:00 or -06:00,
+     * and IANA time zone IDs, such as Europe/Rome
+     *
+     * Affects all filters and aggregations returned values.
+     * You may override this behavior in a specific filter by providing
+     * timestamps including time zone. e.g. `"2023-12-20T10:52:34.795Z"`
      */
-    slug?: string;
-    /** ID of the entity associated with the event. */
-    entityId?: string;
-    /** Event timestamp. */
-    eventTime?: Date;
+    timeZone?: string | null;
+}
+/** @oneof */
+interface CursorSearchPagingMethodOneOf {
     /**
-     * Whether the event was triggered as a result of a privacy regulation application
-     * (for example, GDPR).
+     * Cursor pointing to page of results.
+     * When requesting 'cursor_paging.cursor', no `filter`, `sort` or `search` can be provided.
      */
-    triggeredByAnonymizeRequest?: boolean | null;
-    /** If present, indicates the action that triggered the event. */
-    originatedFrom?: string | null;
+    cursorPaging?: CursorPaging;
+}
+interface Aggregation extends AggregationKindOneOf {
+    value?: ValueAggregation;
+    range?: RangeAggregation;
+    scalar?: ScalarAggregation;
+    dateHistogram?: DateHistogramAggregation;
+    nested?: NestedAggregation;
+    name?: string | null;
+    type?: AggregationType;
+    fieldPath?: string;
+    /** @deprecated */
+    groupBy?: GroupByAggregation;
+}
+/** @oneof */
+interface AggregationKindOneOf {
+    value?: ValueAggregation;
+    range?: RangeAggregation;
+    scalar?: ScalarAggregation;
+    dateHistogram?: DateHistogramAggregation;
+    nested?: NestedAggregation;
+}
+interface RangeBucket {
+    /** Inclusive lower bound of the range. Required if to is not given. */
+    from?: number | null;
+    /** Exclusive upper bound of the range. Required if from is not given. */
+    to?: number | null;
+}
+declare enum SortType {
+    COUNT = "COUNT",
+    VALUE = "VALUE"
+}
+declare enum SortDirection {
+    DESC = "DESC",
+    ASC = "ASC"
+}
+declare enum MissingValues {
+    EXCLUDE = "EXCLUDE",
+    INCLUDE = "INCLUDE"
+}
+interface IncludeMissingValuesOptions {
+    /** can specify custom bucket name. Defaults are [string -> "N/A"], [int -> "0"], [bool -> "false"] ... */
+    addToBucket?: string;
+}
+declare enum ScalarType {
+    UNKNOWN_SCALAR_TYPE = "UNKNOWN_SCALAR_TYPE",
+    COUNT_DISTINCT = "COUNT_DISTINCT",
+    MIN = "MIN",
+    MAX = "MAX",
+    SUM = "SUM",
+    AVG = "AVG"
+}
+interface ValueAggregation extends ValueAggregationOptionsOneOf {
+    /** options for including missing values */
+    includeOptions?: IncludeMissingValuesOptions;
+    sortType?: SortType;
+    sortDirection?: SortDirection;
+    /** How many aggregations would you like to return? Can be between 1 and 250. 10 is the default. */
+    limit?: number | null;
+    /** should missing values be included or excluded from the aggregation results. Default is EXCLUDE */
+    missingValues?: MissingValues;
+}
+/** @oneof */
+interface ValueAggregationOptionsOneOf {
+    /** options for including missing values */
+    includeOptions?: IncludeMissingValuesOptions;
+}
+declare enum NestedAggregationType {
+    UNKNOWN_AGGREGATION_TYPE = "UNKNOWN_AGGREGATION_TYPE",
+    VALUE = "VALUE",
+    RANGE = "RANGE",
+    SCALAR = "SCALAR",
+    DATE_HISTOGRAM = "DATE_HISTOGRAM"
+}
+interface RangeAggregation {
+    /** Range buckets */
+    buckets?: RangeBucket[];
+}
+interface ScalarAggregation {
+    type?: ScalarType;
+}
+interface DateHistogramAggregation {
+    interval?: DateHistogramAggregationInterval;
+}
+declare enum DateHistogramAggregationInterval {
+    UNKNOWN_INTERVAL = "UNKNOWN_INTERVAL",
+    YEAR = "YEAR",
+    MONTH = "MONTH",
+    WEEK = "WEEK",
+    DAY = "DAY",
+    HOUR = "HOUR",
+    MINUTE = "MINUTE",
+    SECOND = "SECOND"
+}
+interface NestedAggregationItem extends NestedAggregationItemKindOneOf {
+    value?: ValueAggregation;
+    range?: RangeAggregation;
+    scalar?: ScalarAggregation;
+    dateHistogram?: DateHistogramAggregation;
+    name?: string | null;
+    type?: NestedAggregationType;
+    fieldPath?: string;
+}
+/** @oneof */
+interface NestedAggregationItemKindOneOf {
+    value?: ValueAggregation;
+    range?: RangeAggregation;
+    scalar?: ScalarAggregation;
+    dateHistogram?: DateHistogramAggregation;
+}
+declare enum AggregationType {
+    UNKNOWN_AGGREGATION_TYPE = "UNKNOWN_AGGREGATION_TYPE",
+    VALUE = "VALUE",
+    RANGE = "RANGE",
+    SCALAR = "SCALAR",
+    DATE_HISTOGRAM = "DATE_HISTOGRAM",
+    NESTED = "NESTED"
+}
+/** nested aggregation expressed through a list of aggregation where each next aggregation is nested within previous one */
+interface NestedAggregation {
+    nestedAggregations?: NestedAggregationItem[];
+}
+interface GroupByAggregation extends GroupByAggregationKindOneOf {
+    value?: ValueAggregation;
+    name?: string | null;
+    fieldPath?: string;
+}
+/** @oneof */
+interface GroupByAggregationKindOneOf {
+    value?: ValueAggregation;
+}
+interface SearchDetails {
+    /** Boolean search mode */
+    mode?: Mode;
+    /** Search term or expression */
+    expression?: string | null;
+    /** Fields to search in. If empty - server will search in own default fields */
+    fields?: string[];
+    /** Flag if should use auto fuzzy search (allowing typos by a managed proximity algorithm) */
+    fuzzy?: boolean;
+}
+declare enum Mode {
+    /** Any */
+    OR = "OR",
+    /** All */
+    AND = "AND"
+}
+interface SearchServicesResponse {
+    /** The retrieved services. */
+    services?: Service[];
+    /** Cursor paging metadata */
+    pagingMetadata?: CursorPagingMetadata;
+    /** Response aggregation data */
+    aggregationData?: AggregationData;
+}
+interface CursorPagingMetadata {
+    /** Number of items returned in the response. */
+    count?: number | null;
+    /** Use these cursor to paginate between results. [Read more](https://dev.wix.com/api/rest/getting-started/api-query-language#getting-started_api-query-language_cursor-paging). */
+    cursors?: Cursors$1;
     /**
-     * A sequence number defining the order of updates to the underlying entity.
-     * For example, given that some entity was updated at 16:00 and than again at 16:01,
-     * it is guaranteed that the sequence number of the second update is strictly higher than the first.
-     * As the consumer, you can use this value to ensure that you handle messages in the correct order.
-     * To do so, you will need to persist this number on your end, and compare the sequence number from the
-     * message against the one you have stored. Given that the stored number is higher, you should ignore the message.
+     * Indicates if there are more results after the current page.
+     * If `true`, another page of results can be retrieved.
+     * If `false`, this is the last page.
      */
-    entityEventSequence?: string | null;
+    hasNext?: boolean | null;
 }
-interface ServiceCreatedEnvelope {
-    entity: Service;
-    metadata: EventMetadata$1;
+interface AggregationData {
+    /** key = aggregation name (as derived from search request) */
+    results?: AggregationResults[];
 }
-interface ServiceUpdatedEnvelope {
-    entity: Service;
-    metadata: EventMetadata$1;
+interface ValueAggregationResult {
+    value?: string;
+    count?: number;
 }
-interface ServiceDeletedEnvelope {
-    metadata: EventMetadata$1;
+interface RangeAggregationResult {
+    from?: number | null;
+    to?: number | null;
+    count?: number;
 }
-interface UpdateService {
+interface NestedAggregationResults extends NestedAggregationResultsResultOneOf {
+    values?: ValueResults;
+    ranges?: RangeResults;
+    scalar?: AggregationResultsScalarResult;
+    name?: string;
+    type?: AggregationType;
+    fieldPath?: string;
+}
+/** @oneof */
+interface NestedAggregationResultsResultOneOf {
+    values?: ValueResults;
+    ranges?: RangeResults;
+    scalar?: AggregationResultsScalarResult;
+}
+interface ValueResults {
+    results?: ValueAggregationResult[];
+}
+interface RangeResults {
+    results?: RangeAggregationResult[];
+}
+interface AggregationResultsScalarResult {
+    type?: ScalarType;
+    value?: number;
+}
+interface NestedValueAggregationResult {
+    value?: string;
+    nestedResults?: NestedAggregationResults;
+}
+interface ValueResult {
+    value?: string;
+    count?: number | null;
+}
+interface RangeResult {
+    from?: number | null;
+    to?: number | null;
+    count?: number | null;
+}
+interface ScalarResult {
+    value?: number;
+}
+interface NestedResultValue extends NestedResultValueResultOneOf {
+    value?: ValueResult;
+    range?: RangeResult;
+    scalar?: ScalarResult;
+    dateHistogram?: ValueResult;
+}
+/** @oneof */
+interface NestedResultValueResultOneOf {
+    value?: ValueResult;
+    range?: RangeResult;
+    scalar?: ScalarResult;
+    dateHistogram?: ValueResult;
+}
+interface Results {
+    results?: Record<string, NestedResultValue>;
+}
+interface DateHistogramResult {
+    value?: string;
+    count?: number;
+}
+interface GroupByValueResults {
+    results?: NestedValueAggregationResult[];
+}
+interface DateHistogramResults {
+    results?: DateHistogramResult[];
+}
+/**
+ * results of `NESTED` aggregation type in a flattened form
+ * aggregations in resulting array are keyed by requested aggregation `name`.
+ */
+interface NestedResults {
+    results?: Results[];
+}
+interface AggregationResults extends AggregationResultsResultOneOf {
+    values?: ValueResults;
+    ranges?: RangeResults;
+    scalar?: AggregationResultsScalarResult;
+    groupedByValue?: GroupByValueResults;
+    dateHistogram?: DateHistogramResults;
+    nested?: NestedResults;
+    name?: string;
+    type?: AggregationType;
+    fieldPath?: string;
+}
+/** @oneof */
+interface AggregationResultsResultOneOf {
+    values?: ValueResults;
+    ranges?: RangeResults;
+    scalar?: AggregationResultsScalarResult;
+    groupedByValue?: GroupByValueResults;
+    dateHistogram?: DateHistogramResults;
+    nested?: NestedResults;
+}
+interface CursorQuery extends CursorQueryPagingMethodOneOf {
+    /** 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;
     /**
-     * Service ID.
-     * @readonly
+     * Filter object in the following format:
+     * `"filter" : {
+     * "fieldName1": "value1",
+     * "fieldName2":{"$operator":"value2"}
+     * }`
+     * Example of operators: `$eq`, `$ne`, `$lt`, `$lte`, `$gt`, `$gte`, `$in`, `$hasSome`, `$hasAll`, `$startsWith`
      */
-    _id?: string | null;
-    /** Service type. */
-    type?: ServiceType;
-    /** Order of a service within a category. */
-    sortOrder?: number | null;
-    name?: string | null;
-    description?: string | null;
-    tagLine?: string | null;
-    /** Default maximum number of customers that can book the service. The service cannot be booked beyond this capacity. */
-    defaultCapacity?: number | null;
-    /** Media associated with the service. */
-    media?: Media;
-    /** Whether the service is hidden from the site. */
-    hidden?: boolean | null;
-    /** The category the service is associated with. */
-    category?: V2Category;
-    /** The form used when booking the service. */
-    form?: Form;
-    /** Payment options for booking the service. */
-    payment?: Payment;
-    /** Online booking settings. */
-    onlineBooking?: OnlineBooking;
-    /** Conferencing options for this service. */
-    conferencing?: Conferencing;
+    filter?: Record<string, any> | null;
     /**
-     * The locations this service is offered at.
-     * In case of multiple (more than 1) location, All locations must be of type `BUSINESS`.
-     * For courses only: Currently, only 1 location is supported, for all location types.
+     * Sort object in the following format:
+     * `[{"fieldName":"sortField1","order":"ASC"},{"fieldName":"sortField2","order":"DESC"}]`
      */
-    locations?: V2Location[];
-    /** Policy determining under what conditions this service can be booked. For example, whether the service can only be booked up to 30 minutes before it begins. */
-    bookingPolicy?: BookingPolicy;
-    /** The service's schedule, which can be used to manage the service's sessions. */
-    schedule?: V2Schedule;
-    /** IDs of the staff members providing the service. For appointments only. */
-    staffMemberIds?: string[];
+    sort?: Sorting[];
+}
+/** @oneof */
+interface CursorQueryPagingMethodOneOf {
+    /** 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;
+}
+interface QueryPoliciesResponse {
+    /** The retrieved policies. */
+    bookingPolicies?: BookingPolicyWithServices[];
+    /** Paging metadata, including offset and count. */
+    pagingMetadata?: CursorPagingMetadata;
+}
+interface BookingPolicyWithServices {
+    /** The booking policy. */
+    bookingPolicy?: BookingPolicy;
+    /** The services associated with the booking policy. Up to 5 services are returned per policy. */
+    services?: Service[];
+    /** Whether there are more services associated with the booking policy. */
+    hasMoreServices?: boolean | null;
+    /** The number of services associated with the booking policy. */
+    countOfServices?: number;
+}
+interface CountServicesResponse {
+    /** The number of services matching the given filter. */
+    count?: number;
+}
+interface RemovedLocationSessionsAction extends RemovedLocationSessionsActionActionOptionsOneOf {
+    /** Options related to the action, such as a new location to move existing sessions to. */
+    moveToLocationOptions?: MoveToNewLocationsOptions;
+    /** The action to perform on sessions currently set to a removed location. For example, move existing sessions to a new specified location. */
+    action?: Action;
+}
+/** @oneof */
+interface RemovedLocationSessionsActionActionOptionsOneOf {
+    /** Options related to the action, such as a new location to move existing sessions to. */
+    moveToLocationOptions?: MoveToNewLocationsOptions;
+}
+declare enum Action {
+    UNKNOWN_ACTION_TYPE = "UNKNOWN_ACTION_TYPE",
+    /**
+     * Keep future sessions at their current location. This is the default.
+     * Note: The location will be set directly on the session. i.e, if the location is currently inherited from the schedule, the inheritance will be overridden.
+     */
+    KEEP_AT_CURRENT_LOCATION = "KEEP_AT_CURRENT_LOCATION",
+    /**
+     * Move future sessions to a new location.
+     * The new location must be specified in the availability locations to set ('SetAvailabilityLocationsRequest.locations').
+     */
+    MOVE_TO_LOCATION = "MOVE_TO_LOCATION",
+    /**
+     * Delete future sessions.
+     * Currently not supported.
+     */
+    DELETE = "DELETE"
+}
+interface MoveToNewLocationsOptions {
+    /** The new location to move existing sessions currently set to a removed location, used when `action` is `MOVE_TO_LOCATION`. */
+    newLocation?: V2Location;
+}
+interface SetServiceLocationsResponse {
+    /** The updated service with the newly set locations. */
+    service?: Service;
+}
+interface EnablePricingPlansForServiceResponse {
+    /** IDs of the pricing plans connected to the service. */
+    pricingPlanIds?: string[];
+    /** The service after the pricing plans update. */
+    service?: Service;
+}
+interface DisablePricingPlansForServiceResponse {
+    /** The service after the pricing plans update. */
+    service?: Service;
+}
+interface SetCustomSlugResponse {
+    /** The new slug set as the active slug for the service. */
+    slug?: Slug;
+    /** The service after the custom slug update. */
+    service?: Service;
+}
+interface ValidateSlugResponse {
+    /** Whether the requested slug name is valid. */
+    valid?: boolean;
+    /** The requested custom slug name to validate. If valid, the slug name can be set as a slug for the service and is populated with the requested slug. Otherwise, `slugName` is empty. */
+    slugName?: string | null;
+    /** If the slug is invalid, this field is populated with the reasons why the slug is invalid. Validation errors may include `SLUG_IS_TOO_LONG`, `SLUG_CONTAIN_ILLEGAL_CHARACTERS`, and `SLUG_ALREADY_EXISTS`. */
+    errors?: InvalidSlugError[];
+}
+declare enum InvalidSlugError {
+    UNKNOWN_SLUG_ERROR = "UNKNOWN_SLUG_ERROR",
+    /** The provided slug name contains illegal characters. */
+    SLUG_CONTAINS_ILLEGAL_CHARACTERS = "SLUG_CONTAINS_ILLEGAL_CHARACTERS",
+    /** The provided slug name already exists for another service. */
+    SLUG_ALREADY_EXISTS = "SLUG_ALREADY_EXISTS"
+}
+interface CloneServiceResponse {
+    /** Cloned service */
+    service?: Service;
+    /** List of entity types that we failed to clone */
+    errors?: CloneErrors[];
+}
+declare enum CloneErrors {
+    UNKNOWN_CLONE_ERROR = "UNKNOWN_CLONE_ERROR",
+    /** Failed to clone sessions of active service's schedule */
+    SESSIONS = "SESSIONS",
+    /** Failed to clone service's options and variants even though source service have them */
+    OPTIONS_AND_VARIANTS = "OPTIONS_AND_VARIANTS",
+    /** Failed to clone service's form */
+    FORM = "FORM",
+    /** Failed to clone pricing plans connected to the source service */
+    PRICING_PLANS = "PRICING_PLANS"
+}
+interface BulkUpdateServicesResponseNonNullableFields {
+    results: {
+        itemMetadata?: {
+            originalIndex: number;
+            success: boolean;
+            error?: {
+                code: string;
+                description: string;
+            };
+        };
+        item?: {
+            type: ServiceType;
+            media?: {
+                items: {
+                    image: string;
+                }[];
+                mainMedia?: {
+                    image: string;
+                };
+                coverMedia?: {
+                    image: string;
+                };
+            };
+            category?: {
+                _id: string;
+            };
+            form?: {
+                _id: string;
+            };
+            payment?: {
+                fixed?: {
+                    price?: {
+                        value: string;
+                        currency: string;
+                    };
+                    deposit?: {
+                        value: string;
+                        currency: string;
+                    };
+                };
+                varied?: {
+                    defaultPrice?: {
+                        value: string;
+                        currency: string;
+                    };
+                    deposit?: {
+                        value: string;
+                        currency: string;
+                    };
+                    minPrice?: {
+                        value: string;
+                        currency: string;
+                    };
+                    maxPrice?: {
+                        value: string;
+                        currency: string;
+                    };
+                };
+                rateType: RateType;
+                pricingPlanIds: string[];
+            };
+            locations: {
+                business?: {
+                    _id: string;
+                    name: string;
+                };
+                custom?: {
+                    _id: string;
+                };
+                _id: string;
+                type: LocationTypeEnumLocationType;
+            }[];
+            bookingPolicy?: {
+                _id: string;
+                customPolicyDescription?: {
+                    enabled: boolean;
+                    description: string;
+                };
+                limitEarlyBookingPolicy?: {
+                    enabled: boolean;
+                    earliestBookingInMinutes: number;
+                };
+                limitLateBookingPolicy?: {
+                    enabled: boolean;
+                    latestBookingInMinutes: number;
+                };
+                bookAfterStartPolicy?: {
+                    enabled: boolean;
+                };
+                cancellationPolicy?: {
+                    enabled: boolean;
+                    limitLatestCancellation: boolean;
+                    latestCancellationInMinutes: number;
+                };
+                reschedulePolicy?: {
+                    enabled: boolean;
+                    limitLatestReschedule: boolean;
+                    latestRescheduleInMinutes: number;
+                };
+                waitlistPolicy?: {
+                    enabled: boolean;
+                    capacity: number;
+                    reservationTimeInMinutes: number;
+                };
+                participantsPolicy?: {
+                    maxParticipantsPerBooking: number;
+                };
+                resourcesPolicy?: {
+                    enabled: boolean;
+                    autoAssignAllowed: boolean;
+                };
+                cancellationFeePolicy?: {
+                    enabled: boolean;
+                    cancellationWindows: {
+                        amount?: {
+                            value: string;
+                            currency: string;
+                        };
+                        percentage: string;
+                    }[];
+                };
+                saveCreditCardPolicy?: {
+                    enabled: boolean;
+                };
+            };
+            schedule?: {
+                availabilityConstraints?: {
+                    sessionDurations: number[];
+                    timeBetweenSessions: number;
+                };
+            };
+            staffMemberIds: string[];
+            supportedSlugs: {
+                name: string;
+            }[];
+            mainSlug?: {
+                name: string;
+            };
+            urls?: {
+                servicePage: string;
+                bookingPage: string;
+                calendarPage: string;
+            };
+            seoData?: {
+                tags: {
+                    type: string;
+                    children: string;
+                    custom: boolean;
+                    disabled: boolean;
+                }[];
+                settings?: {
+                    preventAutoRedirect: boolean;
+                    keywords: {
+                        term: string;
+                        isMain: boolean;
+                    }[];
+                };
+            };
+        };
+    }[];
+    bulkActionMetadata?: {
+        totalSuccesses: number;
+        totalFailures: number;
+        undetailedFailures: number;
+    };
+}
+interface BulkDeleteServicesResponseNonNullableFields {
+    results: {
+        itemMetadata?: {
+            originalIndex: number;
+            success: boolean;
+            error?: {
+                code: string;
+                description: string;
+            };
+        };
+        item?: {
+            type: ServiceType;
+            media?: {
+                items: {
+                    image: string;
+                }[];
+                mainMedia?: {
+                    image: string;
+                };
+                coverMedia?: {
+                    image: string;
+                };
+            };
+            category?: {
+                _id: string;
+            };
+            form?: {
+                _id: string;
+            };
+            payment?: {
+                fixed?: {
+                    price?: {
+                        value: string;
+                        currency: string;
+                    };
+                    deposit?: {
+                        value: string;
+                        currency: string;
+                    };
+                };
+                varied?: {
+                    defaultPrice?: {
+                        value: string;
+                        currency: string;
+                    };
+                    deposit?: {
+                        value: string;
+                        currency: string;
+                    };
+                    minPrice?: {
+                        value: string;
+                        currency: string;
+                    };
+                    maxPrice?: {
+                        value: string;
+                        currency: string;
+                    };
+                };
+                rateType: RateType;
+                pricingPlanIds: string[];
+            };
+            locations: {
+                business?: {
+                    _id: string;
+                    name: string;
+                };
+                custom?: {
+                    _id: string;
+                };
+                _id: string;
+                type: LocationTypeEnumLocationType;
+            }[];
+            bookingPolicy?: {
+                _id: string;
+                customPolicyDescription?: {
+                    enabled: boolean;
+                    description: string;
+                };
+                limitEarlyBookingPolicy?: {
+                    enabled: boolean;
+                    earliestBookingInMinutes: number;
+                };
+                limitLateBookingPolicy?: {
+                    enabled: boolean;
+                    latestBookingInMinutes: number;
+                };
+                bookAfterStartPolicy?: {
+                    enabled: boolean;
+                };
+                cancellationPolicy?: {
+                    enabled: boolean;
+                    limitLatestCancellation: boolean;
+                    latestCancellationInMinutes: number;
+                };
+                reschedulePolicy?: {
+                    enabled: boolean;
+                    limitLatestReschedule: boolean;
+                    latestRescheduleInMinutes: number;
+                };
+                waitlistPolicy?: {
+                    enabled: boolean;
+                    capacity: number;
+                    reservationTimeInMinutes: number;
+                };
+                participantsPolicy?: {
+                    maxParticipantsPerBooking: number;
+                };
+                resourcesPolicy?: {
+                    enabled: boolean;
+                    autoAssignAllowed: boolean;
+                };
+                cancellationFeePolicy?: {
+                    enabled: boolean;
+                    cancellationWindows: {
+                        amount?: {
+                            value: string;
+                            currency: string;
+                        };
+                        percentage: string;
+                    }[];
+                };
+                saveCreditCardPolicy?: {
+                    enabled: boolean;
+                };
+            };
+            schedule?: {
+                availabilityConstraints?: {
+                    sessionDurations: number[];
+                    timeBetweenSessions: number;
+                };
+            };
+            staffMemberIds: string[];
+            supportedSlugs: {
+                name: string;
+            }[];
+            mainSlug?: {
+                name: string;
+            };
+            urls?: {
+                servicePage: string;
+                bookingPage: string;
+                calendarPage: string;
+            };
+            seoData?: {
+                tags: {
+                    type: string;
+                    children: string;
+                    custom: boolean;
+                    disabled: boolean;
+                }[];
+                settings?: {
+                    preventAutoRedirect: boolean;
+                    keywords: {
+                        term: string;
+                        isMain: boolean;
+                    }[];
+                };
+            };
+        };
+    }[];
+    bulkActionMetadata?: {
+        totalSuccesses: number;
+        totalFailures: number;
+        undetailedFailures: number;
+    };
+}
+interface SearchServicesResponseNonNullableFields {
+    services: {
+        type: ServiceType;
+        media?: {
+            items: {
+                image: string;
+            }[];
+            mainMedia?: {
+                image: string;
+            };
+            coverMedia?: {
+                image: string;
+            };
+        };
+        category?: {
+            _id: string;
+        };
+        form?: {
+            _id: string;
+        };
+        payment?: {
+            fixed?: {
+                price?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            varied?: {
+                defaultPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+                minPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                maxPrice?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            rateType: RateType;
+            pricingPlanIds: string[];
+        };
+        locations: {
+            business?: {
+                _id: string;
+                name: string;
+            };
+            custom?: {
+                _id: string;
+            };
+            _id: string;
+            type: LocationTypeEnumLocationType;
+        }[];
+        bookingPolicy?: {
+            _id: string;
+            customPolicyDescription?: {
+                enabled: boolean;
+                description: string;
+            };
+            limitEarlyBookingPolicy?: {
+                enabled: boolean;
+                earliestBookingInMinutes: number;
+            };
+            limitLateBookingPolicy?: {
+                enabled: boolean;
+                latestBookingInMinutes: number;
+            };
+            bookAfterStartPolicy?: {
+                enabled: boolean;
+            };
+            cancellationPolicy?: {
+                enabled: boolean;
+                limitLatestCancellation: boolean;
+                latestCancellationInMinutes: number;
+            };
+            reschedulePolicy?: {
+                enabled: boolean;
+                limitLatestReschedule: boolean;
+                latestRescheduleInMinutes: number;
+            };
+            waitlistPolicy?: {
+                enabled: boolean;
+                capacity: number;
+                reservationTimeInMinutes: number;
+            };
+            participantsPolicy?: {
+                maxParticipantsPerBooking: number;
+            };
+            resourcesPolicy?: {
+                enabled: boolean;
+                autoAssignAllowed: boolean;
+            };
+            cancellationFeePolicy?: {
+                enabled: boolean;
+                cancellationWindows: {
+                    amount?: {
+                        value: string;
+                        currency: string;
+                    };
+                    percentage: string;
+                }[];
+            };
+            saveCreditCardPolicy?: {
+                enabled: boolean;
+            };
+        };
+        schedule?: {
+            availabilityConstraints?: {
+                sessionDurations: number[];
+                timeBetweenSessions: number;
+            };
+        };
+        staffMemberIds: string[];
+        supportedSlugs: {
+            name: string;
+        }[];
+        mainSlug?: {
+            name: string;
+        };
+        urls?: {
+            servicePage: string;
+            bookingPage: string;
+            calendarPage: string;
+        };
+        seoData?: {
+            tags: {
+                type: string;
+                children: string;
+                custom: boolean;
+                disabled: boolean;
+            }[];
+            settings?: {
+                preventAutoRedirect: boolean;
+                keywords: {
+                    term: string;
+                    isMain: boolean;
+                }[];
+            };
+        };
+    }[];
+    aggregationData?: {
+        results: {
+            values?: {
+                results: {
+                    value: string;
+                    count: number;
+                }[];
+            };
+            ranges?: {
+                results: {
+                    count: number;
+                }[];
+            };
+            scalar?: {
+                type: ScalarType;
+                value: number;
+            };
+            groupedByValue?: {
+                results: {
+                    value: string;
+                    nestedResults?: {
+                        values?: {
+                            results: {
+                                value: string;
+                                count: number;
+                            }[];
+                        };
+                        ranges?: {
+                            results: {
+                                count: number;
+                            }[];
+                        };
+                        scalar?: {
+                            type: ScalarType;
+                            value: number;
+                        };
+                        name: string;
+                        type: AggregationType;
+                        fieldPath: string;
+                    };
+                }[];
+            };
+            dateHistogram?: {
+                results: {
+                    value: string;
+                    count: number;
+                }[];
+            };
+            nested?: {
+                results: {
+                    results?: {
+                        value?: {
+                            value: string;
+                        };
+                        scalar?: {
+                            value: number;
+                        };
+                        dateHistogram?: {
+                            value: string;
+                        };
+                    };
+                }[];
+            };
+            name: string;
+            type: AggregationType;
+            fieldPath: string;
+        }[];
+    };
+}
+interface QueryPoliciesResponseNonNullableFields {
+    bookingPolicies: {
+        bookingPolicy?: {
+            _id: string;
+            customPolicyDescription?: {
+                enabled: boolean;
+                description: string;
+            };
+            limitEarlyBookingPolicy?: {
+                enabled: boolean;
+                earliestBookingInMinutes: number;
+            };
+            limitLateBookingPolicy?: {
+                enabled: boolean;
+                latestBookingInMinutes: number;
+            };
+            bookAfterStartPolicy?: {
+                enabled: boolean;
+            };
+            cancellationPolicy?: {
+                enabled: boolean;
+                limitLatestCancellation: boolean;
+                latestCancellationInMinutes: number;
+            };
+            reschedulePolicy?: {
+                enabled: boolean;
+                limitLatestReschedule: boolean;
+                latestRescheduleInMinutes: number;
+            };
+            waitlistPolicy?: {
+                enabled: boolean;
+                capacity: number;
+                reservationTimeInMinutes: number;
+            };
+            participantsPolicy?: {
+                maxParticipantsPerBooking: number;
+            };
+            resourcesPolicy?: {
+                enabled: boolean;
+                autoAssignAllowed: boolean;
+            };
+            cancellationFeePolicy?: {
+                enabled: boolean;
+                cancellationWindows: {
+                    amount?: {
+                        value: string;
+                        currency: string;
+                    };
+                    percentage: string;
+                }[];
+            };
+            saveCreditCardPolicy?: {
+                enabled: boolean;
+            };
+        };
+        services: {
+            type: ServiceType;
+            media?: {
+                items: {
+                    image: string;
+                }[];
+                mainMedia?: {
+                    image: string;
+                };
+                coverMedia?: {
+                    image: string;
+                };
+            };
+            category?: {
+                _id: string;
+            };
+            form?: {
+                _id: string;
+            };
+            payment?: {
+                fixed?: {
+                    price?: {
+                        value: string;
+                        currency: string;
+                    };
+                    deposit?: {
+                        value: string;
+                        currency: string;
+                    };
+                };
+                varied?: {
+                    defaultPrice?: {
+                        value: string;
+                        currency: string;
+                    };
+                    deposit?: {
+                        value: string;
+                        currency: string;
+                    };
+                    minPrice?: {
+                        value: string;
+                        currency: string;
+                    };
+                    maxPrice?: {
+                        value: string;
+                        currency: string;
+                    };
+                };
+                rateType: RateType;
+                pricingPlanIds: string[];
+            };
+            locations: {
+                business?: {
+                    _id: string;
+                    name: string;
+                };
+                custom?: {
+                    _id: string;
+                };
+                _id: string;
+                type: LocationTypeEnumLocationType;
+            }[];
+            bookingPolicy?: {
+                _id: string;
+                customPolicyDescription?: {
+                    enabled: boolean;
+                    description: string;
+                };
+                limitEarlyBookingPolicy?: {
+                    enabled: boolean;
+                    earliestBookingInMinutes: number;
+                };
+                limitLateBookingPolicy?: {
+                    enabled: boolean;
+                    latestBookingInMinutes: number;
+                };
+                bookAfterStartPolicy?: {
+                    enabled: boolean;
+                };
+                cancellationPolicy?: {
+                    enabled: boolean;
+                    limitLatestCancellation: boolean;
+                    latestCancellationInMinutes: number;
+                };
+                reschedulePolicy?: {
+                    enabled: boolean;
+                    limitLatestReschedule: boolean;
+                    latestRescheduleInMinutes: number;
+                };
+                waitlistPolicy?: {
+                    enabled: boolean;
+                    capacity: number;
+                    reservationTimeInMinutes: number;
+                };
+                participantsPolicy?: {
+                    maxParticipantsPerBooking: number;
+                };
+                resourcesPolicy?: {
+                    enabled: boolean;
+                    autoAssignAllowed: boolean;
+                };
+                cancellationFeePolicy?: {
+                    enabled: boolean;
+                    cancellationWindows: {
+                        amount?: {
+                            value: string;
+                            currency: string;
+                        };
+                        percentage: string;
+                    }[];
+                };
+                saveCreditCardPolicy?: {
+                    enabled: boolean;
+                };
+            };
+            schedule?: {
+                availabilityConstraints?: {
+                    sessionDurations: number[];
+                    timeBetweenSessions: number;
+                };
+            };
+            staffMemberIds: string[];
+            supportedSlugs: {
+                name: string;
+            }[];
+            mainSlug?: {
+                name: string;
+            };
+            urls?: {
+                servicePage: string;
+                bookingPage: string;
+                calendarPage: string;
+            };
+            seoData?: {
+                tags: {
+                    type: string;
+                    children: string;
+                    custom: boolean;
+                    disabled: boolean;
+                }[];
+                settings?: {
+                    preventAutoRedirect: boolean;
+                    keywords: {
+                        term: string;
+                        isMain: boolean;
+                    }[];
+                };
+            };
+        }[];
+        countOfServices: number;
+    }[];
+}
+interface CountServicesResponseNonNullableFields {
+    count: number;
+}
+interface SetServiceLocationsResponseNonNullableFields {
+    service?: {
+        type: ServiceType;
+        media?: {
+            items: {
+                image: string;
+            }[];
+            mainMedia?: {
+                image: string;
+            };
+            coverMedia?: {
+                image: string;
+            };
+        };
+        category?: {
+            _id: string;
+        };
+        form?: {
+            _id: string;
+        };
+        payment?: {
+            fixed?: {
+                price?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            varied?: {
+                defaultPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+                minPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                maxPrice?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            rateType: RateType;
+            pricingPlanIds: string[];
+        };
+        locations: {
+            business?: {
+                _id: string;
+                name: string;
+            };
+            custom?: {
+                _id: string;
+            };
+            _id: string;
+            type: LocationTypeEnumLocationType;
+        }[];
+        bookingPolicy?: {
+            _id: string;
+            customPolicyDescription?: {
+                enabled: boolean;
+                description: string;
+            };
+            limitEarlyBookingPolicy?: {
+                enabled: boolean;
+                earliestBookingInMinutes: number;
+            };
+            limitLateBookingPolicy?: {
+                enabled: boolean;
+                latestBookingInMinutes: number;
+            };
+            bookAfterStartPolicy?: {
+                enabled: boolean;
+            };
+            cancellationPolicy?: {
+                enabled: boolean;
+                limitLatestCancellation: boolean;
+                latestCancellationInMinutes: number;
+            };
+            reschedulePolicy?: {
+                enabled: boolean;
+                limitLatestReschedule: boolean;
+                latestRescheduleInMinutes: number;
+            };
+            waitlistPolicy?: {
+                enabled: boolean;
+                capacity: number;
+                reservationTimeInMinutes: number;
+            };
+            participantsPolicy?: {
+                maxParticipantsPerBooking: number;
+            };
+            resourcesPolicy?: {
+                enabled: boolean;
+                autoAssignAllowed: boolean;
+            };
+            cancellationFeePolicy?: {
+                enabled: boolean;
+                cancellationWindows: {
+                    amount?: {
+                        value: string;
+                        currency: string;
+                    };
+                    percentage: string;
+                }[];
+            };
+            saveCreditCardPolicy?: {
+                enabled: boolean;
+            };
+        };
+        schedule?: {
+            availabilityConstraints?: {
+                sessionDurations: number[];
+                timeBetweenSessions: number;
+            };
+        };
+        staffMemberIds: string[];
+        supportedSlugs: {
+            name: string;
+        }[];
+        mainSlug?: {
+            name: string;
+        };
+        urls?: {
+            servicePage: string;
+            bookingPage: string;
+            calendarPage: string;
+        };
+        seoData?: {
+            tags: {
+                type: string;
+                children: string;
+                custom: boolean;
+                disabled: boolean;
+            }[];
+            settings?: {
+                preventAutoRedirect: boolean;
+                keywords: {
+                    term: string;
+                    isMain: boolean;
+                }[];
+            };
+        };
+    };
+}
+interface EnablePricingPlansForServiceResponseNonNullableFields {
+    pricingPlanIds: string[];
+    service?: {
+        type: ServiceType;
+        media?: {
+            items: {
+                image: string;
+            }[];
+            mainMedia?: {
+                image: string;
+            };
+            coverMedia?: {
+                image: string;
+            };
+        };
+        category?: {
+            _id: string;
+        };
+        form?: {
+            _id: string;
+        };
+        payment?: {
+            fixed?: {
+                price?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            varied?: {
+                defaultPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+                minPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                maxPrice?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            rateType: RateType;
+            pricingPlanIds: string[];
+        };
+        locations: {
+            business?: {
+                _id: string;
+                name: string;
+            };
+            custom?: {
+                _id: string;
+            };
+            _id: string;
+            type: LocationTypeEnumLocationType;
+        }[];
+        bookingPolicy?: {
+            _id: string;
+            customPolicyDescription?: {
+                enabled: boolean;
+                description: string;
+            };
+            limitEarlyBookingPolicy?: {
+                enabled: boolean;
+                earliestBookingInMinutes: number;
+            };
+            limitLateBookingPolicy?: {
+                enabled: boolean;
+                latestBookingInMinutes: number;
+            };
+            bookAfterStartPolicy?: {
+                enabled: boolean;
+            };
+            cancellationPolicy?: {
+                enabled: boolean;
+                limitLatestCancellation: boolean;
+                latestCancellationInMinutes: number;
+            };
+            reschedulePolicy?: {
+                enabled: boolean;
+                limitLatestReschedule: boolean;
+                latestRescheduleInMinutes: number;
+            };
+            waitlistPolicy?: {
+                enabled: boolean;
+                capacity: number;
+                reservationTimeInMinutes: number;
+            };
+            participantsPolicy?: {
+                maxParticipantsPerBooking: number;
+            };
+            resourcesPolicy?: {
+                enabled: boolean;
+                autoAssignAllowed: boolean;
+            };
+            cancellationFeePolicy?: {
+                enabled: boolean;
+                cancellationWindows: {
+                    amount?: {
+                        value: string;
+                        currency: string;
+                    };
+                    percentage: string;
+                }[];
+            };
+            saveCreditCardPolicy?: {
+                enabled: boolean;
+            };
+        };
+        schedule?: {
+            availabilityConstraints?: {
+                sessionDurations: number[];
+                timeBetweenSessions: number;
+            };
+        };
+        staffMemberIds: string[];
+        supportedSlugs: {
+            name: string;
+        }[];
+        mainSlug?: {
+            name: string;
+        };
+        urls?: {
+            servicePage: string;
+            bookingPage: string;
+            calendarPage: string;
+        };
+        seoData?: {
+            tags: {
+                type: string;
+                children: string;
+                custom: boolean;
+                disabled: boolean;
+            }[];
+            settings?: {
+                preventAutoRedirect: boolean;
+                keywords: {
+                    term: string;
+                    isMain: boolean;
+                }[];
+            };
+        };
+    };
+}
+interface DisablePricingPlansForServiceResponseNonNullableFields {
+    service?: {
+        type: ServiceType;
+        media?: {
+            items: {
+                image: string;
+            }[];
+            mainMedia?: {
+                image: string;
+            };
+            coverMedia?: {
+                image: string;
+            };
+        };
+        category?: {
+            _id: string;
+        };
+        form?: {
+            _id: string;
+        };
+        payment?: {
+            fixed?: {
+                price?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            varied?: {
+                defaultPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+                minPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                maxPrice?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            rateType: RateType;
+            pricingPlanIds: string[];
+        };
+        locations: {
+            business?: {
+                _id: string;
+                name: string;
+            };
+            custom?: {
+                _id: string;
+            };
+            _id: string;
+            type: LocationTypeEnumLocationType;
+        }[];
+        bookingPolicy?: {
+            _id: string;
+            customPolicyDescription?: {
+                enabled: boolean;
+                description: string;
+            };
+            limitEarlyBookingPolicy?: {
+                enabled: boolean;
+                earliestBookingInMinutes: number;
+            };
+            limitLateBookingPolicy?: {
+                enabled: boolean;
+                latestBookingInMinutes: number;
+            };
+            bookAfterStartPolicy?: {
+                enabled: boolean;
+            };
+            cancellationPolicy?: {
+                enabled: boolean;
+                limitLatestCancellation: boolean;
+                latestCancellationInMinutes: number;
+            };
+            reschedulePolicy?: {
+                enabled: boolean;
+                limitLatestReschedule: boolean;
+                latestRescheduleInMinutes: number;
+            };
+            waitlistPolicy?: {
+                enabled: boolean;
+                capacity: number;
+                reservationTimeInMinutes: number;
+            };
+            participantsPolicy?: {
+                maxParticipantsPerBooking: number;
+            };
+            resourcesPolicy?: {
+                enabled: boolean;
+                autoAssignAllowed: boolean;
+            };
+            cancellationFeePolicy?: {
+                enabled: boolean;
+                cancellationWindows: {
+                    amount?: {
+                        value: string;
+                        currency: string;
+                    };
+                    percentage: string;
+                }[];
+            };
+            saveCreditCardPolicy?: {
+                enabled: boolean;
+            };
+        };
+        schedule?: {
+            availabilityConstraints?: {
+                sessionDurations: number[];
+                timeBetweenSessions: number;
+            };
+        };
+        staffMemberIds: string[];
+        supportedSlugs: {
+            name: string;
+        }[];
+        mainSlug?: {
+            name: string;
+        };
+        urls?: {
+            servicePage: string;
+            bookingPage: string;
+            calendarPage: string;
+        };
+        seoData?: {
+            tags: {
+                type: string;
+                children: string;
+                custom: boolean;
+                disabled: boolean;
+            }[];
+            settings?: {
+                preventAutoRedirect: boolean;
+                keywords: {
+                    term: string;
+                    isMain: boolean;
+                }[];
+            };
+        };
+    };
+}
+interface SetCustomSlugResponseNonNullableFields {
+    slug?: {
+        name: string;
+    };
+    service?: {
+        type: ServiceType;
+        media?: {
+            items: {
+                image: string;
+            }[];
+            mainMedia?: {
+                image: string;
+            };
+            coverMedia?: {
+                image: string;
+            };
+        };
+        category?: {
+            _id: string;
+        };
+        form?: {
+            _id: string;
+        };
+        payment?: {
+            fixed?: {
+                price?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            varied?: {
+                defaultPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+                minPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                maxPrice?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            rateType: RateType;
+            pricingPlanIds: string[];
+        };
+        locations: {
+            business?: {
+                _id: string;
+                name: string;
+            };
+            custom?: {
+                _id: string;
+            };
+            _id: string;
+            type: LocationTypeEnumLocationType;
+        }[];
+        bookingPolicy?: {
+            _id: string;
+            customPolicyDescription?: {
+                enabled: boolean;
+                description: string;
+            };
+            limitEarlyBookingPolicy?: {
+                enabled: boolean;
+                earliestBookingInMinutes: number;
+            };
+            limitLateBookingPolicy?: {
+                enabled: boolean;
+                latestBookingInMinutes: number;
+            };
+            bookAfterStartPolicy?: {
+                enabled: boolean;
+            };
+            cancellationPolicy?: {
+                enabled: boolean;
+                limitLatestCancellation: boolean;
+                latestCancellationInMinutes: number;
+            };
+            reschedulePolicy?: {
+                enabled: boolean;
+                limitLatestReschedule: boolean;
+                latestRescheduleInMinutes: number;
+            };
+            waitlistPolicy?: {
+                enabled: boolean;
+                capacity: number;
+                reservationTimeInMinutes: number;
+            };
+            participantsPolicy?: {
+                maxParticipantsPerBooking: number;
+            };
+            resourcesPolicy?: {
+                enabled: boolean;
+                autoAssignAllowed: boolean;
+            };
+            cancellationFeePolicy?: {
+                enabled: boolean;
+                cancellationWindows: {
+                    amount?: {
+                        value: string;
+                        currency: string;
+                    };
+                    percentage: string;
+                }[];
+            };
+            saveCreditCardPolicy?: {
+                enabled: boolean;
+            };
+        };
+        schedule?: {
+            availabilityConstraints?: {
+                sessionDurations: number[];
+                timeBetweenSessions: number;
+            };
+        };
+        staffMemberIds: string[];
+        supportedSlugs: {
+            name: string;
+        }[];
+        mainSlug?: {
+            name: string;
+        };
+        urls?: {
+            servicePage: string;
+            bookingPage: string;
+            calendarPage: string;
+        };
+        seoData?: {
+            tags: {
+                type: string;
+                children: string;
+                custom: boolean;
+                disabled: boolean;
+            }[];
+            settings?: {
+                preventAutoRedirect: boolean;
+                keywords: {
+                    term: string;
+                    isMain: boolean;
+                }[];
+            };
+        };
+    };
+}
+interface ValidateSlugResponseNonNullableFields {
+    valid: boolean;
+    errors: InvalidSlugError[];
+}
+interface CloneServiceResponseNonNullableFields {
+    service?: {
+        type: ServiceType;
+        media?: {
+            items: {
+                image: string;
+            }[];
+            mainMedia?: {
+                image: string;
+            };
+            coverMedia?: {
+                image: string;
+            };
+        };
+        category?: {
+            _id: string;
+        };
+        form?: {
+            _id: string;
+        };
+        payment?: {
+            fixed?: {
+                price?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            varied?: {
+                defaultPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                deposit?: {
+                    value: string;
+                    currency: string;
+                };
+                minPrice?: {
+                    value: string;
+                    currency: string;
+                };
+                maxPrice?: {
+                    value: string;
+                    currency: string;
+                };
+            };
+            rateType: RateType;
+            pricingPlanIds: string[];
+        };
+        locations: {
+            business?: {
+                _id: string;
+                name: string;
+            };
+            custom?: {
+                _id: string;
+            };
+            _id: string;
+            type: LocationTypeEnumLocationType;
+        }[];
+        bookingPolicy?: {
+            _id: string;
+            customPolicyDescription?: {
+                enabled: boolean;
+                description: string;
+            };
+            limitEarlyBookingPolicy?: {
+                enabled: boolean;
+                earliestBookingInMinutes: number;
+            };
+            limitLateBookingPolicy?: {
+                enabled: boolean;
+                latestBookingInMinutes: number;
+            };
+            bookAfterStartPolicy?: {
+                enabled: boolean;
+            };
+            cancellationPolicy?: {
+                enabled: boolean;
+                limitLatestCancellation: boolean;
+                latestCancellationInMinutes: number;
+            };
+            reschedulePolicy?: {
+                enabled: boolean;
+                limitLatestReschedule: boolean;
+                latestRescheduleInMinutes: number;
+            };
+            waitlistPolicy?: {
+                enabled: boolean;
+                capacity: number;
+                reservationTimeInMinutes: number;
+            };
+            participantsPolicy?: {
+                maxParticipantsPerBooking: number;
+            };
+            resourcesPolicy?: {
+                enabled: boolean;
+                autoAssignAllowed: boolean;
+            };
+            cancellationFeePolicy?: {
+                enabled: boolean;
+                cancellationWindows: {
+                    amount?: {
+                        value: string;
+                        currency: string;
+                    };
+                    percentage: string;
+                }[];
+            };
+            saveCreditCardPolicy?: {
+                enabled: boolean;
+            };
+        };
+        schedule?: {
+            availabilityConstraints?: {
+                sessionDurations: number[];
+                timeBetweenSessions: number;
+            };
+        };
+        staffMemberIds: string[];
+        supportedSlugs: {
+            name: string;
+        }[];
+        mainSlug?: {
+            name: string;
+        };
+        urls?: {
+            servicePage: string;
+            bookingPage: string;
+            calendarPage: string;
+        };
+        seoData?: {
+            tags: {
+                type: string;
+                children: string;
+                custom: boolean;
+                disabled: boolean;
+            }[];
+            settings?: {
+                preventAutoRedirect: boolean;
+                keywords: {
+                    term: string;
+                    isMain: boolean;
+                }[];
+            };
+        };
+    };
+    errors: CloneErrors[];
+}
+interface BaseEventMetadata$2 {
+    /** App instance ID. */
+    instanceId?: string | null;
+    /** Event type. */
+    eventType?: string;
+    /** The identification type and identity data. */
+    identity?: IdentificationData$3;
+}
+interface EventMetadata$1 extends BaseEventMetadata$2 {
+    /**
+     * Unique event ID.
+     * Allows clients to ignore duplicate webhooks.
+     */
+    _id?: string;
+    /**
+     * Assumes actions are also always typed to an entity_type
+     * Example: wix.stores.catalog.product, wix.bookings.session, wix.payments.transaction
+     */
+    entityFqdn?: string;
+    /**
+     * This is top level to ease client code dispatching of messages (switch on entity_fqdn+slug)
+     * This is although the created/updated/deleted notion is duplication of the oneof types
+     * Example: created/updated/deleted/started/completed/email_opened
+     */
+    slug?: string;
+    /** ID of the entity associated with the event. */
+    entityId?: string;
+    /** Event timestamp. */
+    eventTime?: Date;
+    /**
+     * Whether the event was triggered as a result of a privacy regulation application
+     * (for example, GDPR).
+     */
+    triggeredByAnonymizeRequest?: boolean | null;
+    /** If present, indicates the action that triggered the event. */
+    originatedFrom?: string | null;
+    /**
+     * A sequence number defining the order of updates to the underlying entity.
+     * For example, given that some entity was updated at 16:00 and than again at 16:01,
+     * it is guaranteed that the sequence number of the second update is strictly higher than the first.
+     * As the consumer, you can use this value to ensure that you handle messages in the correct order.
+     * To do so, you will need to persist this number on your end, and compare the sequence number from the
+     * message against the one you have stored. Given that the stored number is higher, you should ignore the message.
+     */
+    entityEventSequence?: string | null;
+}
+interface ServiceCreatedEnvelope {
+    entity: Service;
+    metadata: EventMetadata$1;
+}
+interface ServiceUpdatedEnvelope {
+    entity: Service;
+    metadata: EventMetadata$1;
+}
+interface ServiceDeletedEnvelope {
+    metadata: EventMetadata$1;
+}
+interface UpdateService {
+    /**
+     * Service ID.
+     * @readonly
+     */
+    _id?: string | null;
+    /** Service type. */
+    type?: ServiceType;
+    /** Order of a service within a category. */
+    sortOrder?: number | null;
+    name?: string | null;
+    description?: string | null;
+    tagLine?: string | null;
+    /** Default maximum number of customers that can book the service. The service cannot be booked beyond this capacity. */
+    defaultCapacity?: number | null;
+    /** Media associated with the service. */
+    media?: Media;
+    /** Whether the service is hidden from the site. */
+    hidden?: boolean | null;
+    /** The category the service is associated with. */
+    category?: V2Category;
+    /** The form used when booking the service. */
+    form?: Form;
+    /** Payment options for booking the service. */
+    payment?: Payment;
+    /** Online booking settings. */
+    onlineBooking?: OnlineBooking;
+    /** Conferencing options for this service. */
+    conferencing?: Conferencing;
+    /**
+     * The locations this service is offered at.
+     * In case of multiple (more than 1) location, All locations must be of type `BUSINESS`.
+     * For courses only: Currently, only 1 location is supported, for all location types.
+     */
+    locations?: V2Location[];
+    /** Policy determining under what conditions this service can be booked. For example, whether the service can only be booked up to 30 minutes before it begins. */
+    bookingPolicy?: BookingPolicy;
+    /** The service's schedule, which can be used to manage the service's sessions. */
+    schedule?: V2Schedule;
+    /** IDs of the staff members providing the service. For appointments only. */
+    staffMemberIds?: string[];
     /**
      * A slug is the last part of the URL address that serves as a unique identifier of the service.
      * The list of supported slugs includes past service names for backwards compatibility, and a custom slug if one was set by the business owner.
@@ -4666,6 +6692,12 @@ interface UpdateService {
      */
     revision?: string | null;
 }
+interface BulkUpdateServicesOptions {
+    /** Services to update. */
+    services?: MaskedService[];
+    /** `true` if the updated entities must be included in the response, otherwise no entities are included in the response. */
+    returnEntity?: boolean;
+}
 interface DeleteServiceOptions {
     /**
      * Whether to preserve future sessions with participants.
@@ -4676,6 +6708,16 @@ interface DeleteServiceOptions {
     /** Whether to notify participants about the change and an optional custom message. */
     participantNotification?: V2ParticipantNotification;
 }
+interface BulkDeleteServicesOptions {
+    /**
+     * Whether to preserve future sessions with participants.
+     *
+     * Default: `false`.
+     */
+    preserveFutureSessionsWithParticipants?: boolean;
+    /** Whether to notify participants about the change and an optional custom message. */
+    participantNotification?: V2ParticipantNotification;
+}
 interface QueryServicesOptions {
 }
 interface QueryOffsetResult {
@@ -4738,6 +6780,30 @@ interface CountServicesOptions {
     /** The filters for performing the count. */
     filter?: Record<string, any> | null;
 }
+interface SetServiceLocationsOptions {
+    /** The action to perform on sessions currently set to a removed location. For example, move existing sessions to a new specified location. */
+    removedLocationSessionsAction?: RemovedLocationSessionsAction;
+    /** Whether to notify participants about the change of location, and an optional custom message. */
+    participantNotification?: V2ParticipantNotification;
+}
+interface DisablePricingPlansForServiceOptions {
+    /** ID of the pricing plans to disconnect from the service. */
+    pricingPlanIds?: string[];
+}
+interface ValidateSlugOptions {
+    /** The custom name to validate as a slug for the service. */
+    slugName: string;
+}
+interface CloneServiceOptions {
+    /** copy recurring sessions of an active service's schedule */
+    copyRecurringSessions?: boolean;
+    /** copy benefits with pricing plans that are connected to the source service. If the source service is connected to more than 120 benefits with pricing plans then they will not be copied. In that case the field `error_types` in the response will include `PRICING_PLANS`. */
+    copyPricingPlans?: boolean;
+    /** whether to hide service from the list or not. Empty means that we will copy this value from the source service without overriding it */
+    hideService?: boolean | null;
+    /** the name of the clone service. The title of the clone service's schedule will also be set to this name. When this parameter is omitted then the clone service will have the same name as the source service and the clone service's schedule will get the same title as the source service's active schedule. */
+    cloneServiceName?: string | null;
+}
 
 declare function createService$1(httpClient: HttpClient): (service: Service) => Promise<Service & {
     type: ServiceType;
@@ -5186,9 +7252,19 @@ declare function updateService$1(httpClient: HttpClient): (_id: string | null, s
         } | undefined;
     } | undefined;
 }>;
+declare function bulkUpdateServices$1(httpClient: HttpClient): (options?: BulkUpdateServicesOptions) => Promise<BulkUpdateServicesResponse & BulkUpdateServicesResponseNonNullableFields>;
 declare function deleteService$1(httpClient: HttpClient): (serviceId: string, options?: DeleteServiceOptions) => Promise<void>;
+declare function bulkDeleteServices$1(httpClient: HttpClient): (ids: string[], options?: BulkDeleteServicesOptions) => Promise<BulkDeleteServicesResponse & BulkDeleteServicesResponseNonNullableFields>;
 declare function queryServices$1(httpClient: HttpClient): (options?: QueryServicesOptions) => ServicesQueryBuilder;
+declare function searchServices$1(httpClient: HttpClient): (search: CursorSearch) => Promise<SearchServicesResponse & SearchServicesResponseNonNullableFields>;
+declare function queryPolicies$1(httpClient: HttpClient): (query: CursorQuery) => Promise<QueryPoliciesResponse & QueryPoliciesResponseNonNullableFields>;
 declare function countServices$1(httpClient: HttpClient): (options?: CountServicesOptions) => Promise<CountServicesResponse & CountServicesResponseNonNullableFields>;
+declare function setServiceLocations$1(httpClient: HttpClient): (serviceId: string, locations: V2Location[], options?: SetServiceLocationsOptions) => Promise<SetServiceLocationsResponse & SetServiceLocationsResponseNonNullableFields>;
+declare function enablePricingPlansForService$1(httpClient: HttpClient): (serviceId: string, pricingPlanIds: string[]) => Promise<EnablePricingPlansForServiceResponse & EnablePricingPlansForServiceResponseNonNullableFields>;
+declare function disablePricingPlansForService$1(httpClient: HttpClient): (serviceId: string, options?: DisablePricingPlansForServiceOptions) => Promise<DisablePricingPlansForServiceResponse & DisablePricingPlansForServiceResponseNonNullableFields>;
+declare function setCustomSlug$1(httpClient: HttpClient): (serviceId: string, slugName: string) => Promise<SetCustomSlugResponse & SetCustomSlugResponseNonNullableFields>;
+declare function validateSlug$1(httpClient: HttpClient): (serviceId: string, options: ValidateSlugOptions) => Promise<ValidateSlugResponse & ValidateSlugResponseNonNullableFields>;
+declare function cloneService$1(httpClient: HttpClient): (sourceServiceId: string, options?: CloneServiceOptions) => Promise<CloneServiceResponse & CloneServiceResponseNonNullableFields>;
 declare const onServiceCreated$1: EventDefinition<ServiceCreatedEnvelope, "wix.bookings.services.v2.service_created">;
 declare const onServiceUpdated$1: EventDefinition<ServiceUpdatedEnvelope, "wix.bookings.services.v2.service_updated">;
 declare const onServiceDeleted$1: EventDefinition<ServiceDeletedEnvelope, "wix.bookings.services.v2.service_deleted">;
@@ -5196,24 +7272,44 @@ declare const onServiceDeleted$1: EventDefinition<ServiceDeletedEnvelope, "wix.b
 declare const createService: BuildRESTFunction<typeof createService$1>;
 declare const getService: BuildRESTFunction<typeof getService$1>;
 declare const updateService: BuildRESTFunction<typeof updateService$1>;
+declare const bulkUpdateServices: BuildRESTFunction<typeof bulkUpdateServices$1>;
 declare const deleteService: BuildRESTFunction<typeof deleteService$1>;
+declare const bulkDeleteServices: BuildRESTFunction<typeof bulkDeleteServices$1>;
 declare const queryServices: BuildRESTFunction<typeof queryServices$1>;
+declare const searchServices: BuildRESTFunction<typeof searchServices$1>;
+declare const queryPolicies: BuildRESTFunction<typeof queryPolicies$1>;
 declare const countServices: BuildRESTFunction<typeof countServices$1>;
+declare const setServiceLocations: BuildRESTFunction<typeof setServiceLocations$1>;
+declare const enablePricingPlansForService: BuildRESTFunction<typeof enablePricingPlansForService$1>;
+declare const disablePricingPlansForService: BuildRESTFunction<typeof disablePricingPlansForService$1>;
+declare const setCustomSlug: BuildRESTFunction<typeof setCustomSlug$1>;
+declare const validateSlug: BuildRESTFunction<typeof validateSlug$1>;
+declare const cloneService: BuildRESTFunction<typeof cloneService$1>;
 declare const onServiceCreated: BuildEventDefinition<typeof onServiceCreated$1>;
 declare const onServiceUpdated: BuildEventDefinition<typeof onServiceUpdated$1>;
 declare const onServiceDeleted: BuildEventDefinition<typeof onServiceDeleted$1>;
 
+declare const context$4_bulkDeleteServices: typeof bulkDeleteServices;
+declare const context$4_bulkUpdateServices: typeof bulkUpdateServices;
+declare const context$4_cloneService: typeof cloneService;
 declare const context$4_countServices: typeof countServices;
 declare const context$4_createService: typeof createService;
 declare const context$4_deleteService: typeof deleteService;
+declare const context$4_disablePricingPlansForService: typeof disablePricingPlansForService;
+declare const context$4_enablePricingPlansForService: typeof enablePricingPlansForService;
 declare const context$4_getService: typeof getService;
 declare const context$4_onServiceCreated: typeof onServiceCreated;
 declare const context$4_onServiceDeleted: typeof onServiceDeleted;
 declare const context$4_onServiceUpdated: typeof onServiceUpdated;
+declare const context$4_queryPolicies: typeof queryPolicies;
 declare const context$4_queryServices: typeof queryServices;
+declare const context$4_searchServices: typeof searchServices;
+declare const context$4_setCustomSlug: typeof setCustomSlug;
+declare const context$4_setServiceLocations: typeof setServiceLocations;
 declare const context$4_updateService: typeof updateService;
+declare const context$4_validateSlug: typeof validateSlug;
 declare namespace context$4 {
-  export { context$4_countServices as countServices, context$4_createService as createService, context$4_deleteService as deleteService, context$4_getService as getService, context$4_onServiceCreated as onServiceCreated, context$4_onServiceDeleted as onServiceDeleted, context$4_onServiceUpdated as onServiceUpdated, context$4_queryServices as queryServices, context$4_updateService as updateService };
+  export { context$4_bulkDeleteServices as bulkDeleteServices, context$4_bulkUpdateServices as bulkUpdateServices, context$4_cloneService as cloneService, context$4_countServices as countServices, context$4_createService as createService, context$4_deleteService as deleteService, context$4_disablePricingPlansForService as disablePricingPlansForService, context$4_enablePricingPlansForService as enablePricingPlansForService, context$4_getService as getService, context$4_onServiceCreated as onServiceCreated, context$4_onServiceDeleted as onServiceDeleted, context$4_onServiceUpdated as onServiceUpdated, context$4_queryPolicies as queryPolicies, context$4_queryServices as queryServices, context$4_searchServices as searchServices, context$4_setCustomSlug as setCustomSlug, context$4_setServiceLocations as setServiceLocations, context$4_updateService as updateService, context$4_validateSlug as validateSlug };
 }
 
 /** Categories are used to group multiple services together. A service must be associated with a category in order to be exposed in the Wix Bookings UI. */