@voyant-travel/operations-react 0.0.0

package/dist/availability/hooks/use-availability-batch-mutations.d.ts

@@ -0,0 +1,193 @@
+import { type BatchUpdateResponse } from "../schemas.js";
+export interface BatchUpdateVariables<TPatch> {
+    ids: string[];
+    patch: TPatch;
+}
+export interface BatchDeleteVariables {
+    ids: string[];
+}
+/** Batch mutations for `POST /v1/operations/availability/rules/{batch-update,batch-delete}`. */
+export declare function useAvailabilityRuleBatchMutation(): {
+    batchUpdate: import("@tanstack/react-query").UseMutationResult<BatchUpdateResponse<{
+        id: string;
+        productId: string;
+        optionId: string | null;
+        facilityId: string | null;
+        timezone: string;
+        recurrenceRule: string;
+        maxCapacity: number;
+        maxPickupCapacity: number | null;
+        minTotalPax: number | null;
+        cutoffMinutes: number | null;
+        earlyBookingLimitMinutes: number | null;
+        active: boolean;
+        productName?: string | null | undefined;
+    }>, Error, BatchUpdateVariables<{
+        productId?: string | undefined;
+        optionId?: string | null | undefined;
+        facilityId?: string | null | undefined;
+        timezone?: string | undefined;
+        recurrenceRule?: string | undefined;
+        maxCapacity?: number | undefined;
+        maxPickupCapacity?: number | null | undefined;
+        minTotalPax?: number | null | undefined;
+        cutoffMinutes?: number | null | undefined;
+        earlyBookingLimitMinutes?: number | null | undefined;
+        active?: boolean | undefined;
+    }>, unknown>;
+    batchDelete: import("@tanstack/react-query").UseMutationResult<{
+        deletedIds: string[];
+        total: number;
+        succeeded: number;
+        failed: {
+            id: string;
+            error: string;
+        }[];
+    }, Error, BatchDeleteVariables, unknown>;
+};
+/** Batch mutations for `POST /v1/operations/availability/start-times/{batch-update,batch-delete}`. */
+export declare function useAvailabilityStartTimeBatchMutation(): {
+    batchUpdate: import("@tanstack/react-query").UseMutationResult<BatchUpdateResponse<{
+        id: string;
+        productId: string;
+        optionId: string | null;
+        facilityId: string | null;
+        label: string | null;
+        startTimeLocal: string;
+        durationMinutes: number | null;
+        sortOrder: number;
+        active: boolean;
+        productName?: string | null | undefined;
+    }>, Error, BatchUpdateVariables<{
+        productId?: string | undefined;
+        optionId?: string | null | undefined;
+        facilityId?: string | null | undefined;
+        label?: string | null | undefined;
+        startTimeLocal?: string | undefined;
+        durationMinutes?: number | null | undefined;
+        sortOrder?: number | undefined;
+        active?: boolean | undefined;
+    }>, unknown>;
+    batchDelete: import("@tanstack/react-query").UseMutationResult<{
+        deletedIds: string[];
+        total: number;
+        succeeded: number;
+        failed: {
+            id: string;
+            error: string;
+        }[];
+    }, Error, BatchDeleteVariables, unknown>;
+};
+/** Batch mutations for `POST /v1/operations/availability/slots/{batch-update,batch-delete}`. */
+export declare function useAvailabilitySlotBatchMutation(): {
+    batchUpdate: import("@tanstack/react-query").UseMutationResult<BatchUpdateResponse<{
+        id: string;
+        productId: string;
+        itineraryId: string | null;
+        optionId: string | null;
+        facilityId: string | null;
+        availabilityRuleId: string | null;
+        startTimeId: string | null;
+        dateLocal: string;
+        startsAt: string;
+        endsAt: string | null;
+        timezone: string;
+        status: "cancelled" | "open" | "closed" | "sold_out";
+        unlimited: boolean;
+        initialPax: number | null;
+        remainingPax: number | null;
+        nights: number | null;
+        days: number | null;
+        notes: string | null;
+        productName?: string | null | undefined;
+        endDateLocal?: string | null | undefined;
+    }>, Error, BatchUpdateVariables<{
+        productId?: string | undefined;
+        itineraryId?: string | null | undefined;
+        optionId?: string | null | undefined;
+        facilityId?: string | null | undefined;
+        availabilityRuleId?: string | null | undefined;
+        startTimeId?: string | null | undefined;
+        dateLocal?: string | undefined;
+        startsAt?: string | undefined;
+        endsAt?: string | null | undefined;
+        timezone?: string | undefined;
+        status?: "cancelled" | "open" | "closed" | "sold_out" | undefined;
+        unlimited?: boolean | undefined;
+        initialPax?: number | null | undefined;
+        remainingPax?: number | null | undefined;
+        initialPickups?: number | null | undefined;
+        remainingPickups?: number | null | undefined;
+        remainingResources?: number | null | undefined;
+        pastCutoff?: boolean | undefined;
+        tooEarly?: boolean | undefined;
+        nights?: number | null | undefined;
+        days?: number | null | undefined;
+        notes?: string | null | undefined;
+    }>, unknown>;
+    batchDelete: import("@tanstack/react-query").UseMutationResult<{
+        deletedIds: string[];
+        total: number;
+        succeeded: number;
+        failed: {
+            id: string;
+            error: string;
+        }[];
+    }, Error, BatchDeleteVariables, unknown>;
+};
+/** Batch mutations for `POST /v1/operations/availability/closeouts/{batch-update,batch-delete}`. */
+export declare function useAvailabilityCloseoutBatchMutation(): {
+    batchUpdate: import("@tanstack/react-query").UseMutationResult<BatchUpdateResponse<{
+        id: string;
+        productId: string;
+        slotId: string | null;
+        dateLocal: string;
+        reason: string | null;
+        createdBy: string | null;
+        productName?: string | null | undefined;
+    }>, Error, BatchUpdateVariables<{
+        productId?: string | undefined;
+        slotId?: string | null | undefined;
+        dateLocal?: string | undefined;
+        reason?: string | null | undefined;
+        createdBy?: string | null | undefined;
+    }>, unknown>;
+    batchDelete: import("@tanstack/react-query").UseMutationResult<{
+        deletedIds: string[];
+        total: number;
+        succeeded: number;
+        failed: {
+            id: string;
+            error: string;
+        }[];
+    }, Error, BatchDeleteVariables, unknown>;
+};
+/** Batch mutations for `POST /v1/operations/availability/pickup-points/{batch-update,batch-delete}`. */
+export declare function useAvailabilityPickupPointBatchMutation(): {
+    batchUpdate: import("@tanstack/react-query").UseMutationResult<BatchUpdateResponse<{
+        id: string;
+        productId: string;
+        name: string;
+        description: string | null;
+        locationText: string | null;
+        active: boolean;
+        productName?: string | null | undefined;
+    }>, Error, BatchUpdateVariables<{
+        productId?: string | undefined;
+        facilityId?: string | null | undefined;
+        name?: string | undefined;
+        description?: string | null | undefined;
+        locationText?: string | null | undefined;
+        active?: boolean | undefined;
+    }>, unknown>;
+    batchDelete: import("@tanstack/react-query").UseMutationResult<{
+        deletedIds: string[];
+        total: number;
+        succeeded: number;
+        failed: {
+            id: string;
+            error: string;
+        }[];
+    }, Error, BatchDeleteVariables, unknown>;
+};
+//# sourceMappingURL=use-availability-batch-mutations.d.ts.map

package/dist/availability/hooks/use-availability-batch-mutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-availability-batch-mutations.d.ts","sourceRoot":"","sources":["../../../src/availability/hooks/use-availability-batch-mutations.ts"],"names":[],"mappings":"AAQA,OAAO,EAOL,KAAK,mBAAmB,EAQzB,MAAM,eAAe,CAAA;AAEtB,MAAM,WAAW,oBAAoB,CAAC,MAAM;IAC1C,GAAG,EAAE,MAAM,EAAE,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,EAAE,CAAA;CACd;AAoDD,gGAAgG;AAChG,wBAAgB,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK/C;AAED,sGAAsG;AACtG,wBAAgB,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASpD;AAED,gGAAgG;AAChG,wBAAgB,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK/C;AAED,oGAAoG;AACpG,wBAAgB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;EASnD;AAED,wGAAwG;AACxG,wBAAgB,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;EAStD"}

package/dist/availability/hooks/use-availability-batch-mutations.js

@@ -0,0 +1,53 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantAvailabilityContext } from "../provider.js";
+import { availabilityQueryKeys } from "../query-keys.js";
+import { availabilityCloseoutRecordSchema, availabilityPickupPointRecordSchema, availabilityRuleRecordSchema, availabilitySlotRecordSchema, availabilityStartTimeRecordSchema, batchDeleteEnvelope, batchUpdateEnvelope, } from "../schemas.js";
+/**
+ * Shared plumbing for the `POST <entity>/batch-update` + `/batch-delete`
+ * endpoint pairs the availability module exposes for every list entity.
+ * Each mutation sends the whole id selection in one request and resolves
+ * the server's success/partial-failure envelope (`{ total, succeeded,
+ * failed }` plus the updated rows on update / `deletedIds` on delete) —
+ * callers branch their toasts on `failed.length`. Invalidation is scoped
+ * to the entity's query-key root, mirroring the single-record mutation
+ * hooks.
+ */
+function useAvailabilityBatchMutationPair(basePath, recordSchema, queryKey) {
+    const { baseUrl, fetcher } = useVoyantAvailabilityContext();
+    const queryClient = useQueryClient();
+    const batchUpdate = useMutation({
+        mutationFn: async ({ ids, patch, }) => fetchWithValidation(`${basePath}/batch-update`, batchUpdateEnvelope(recordSchema), { baseUrl, fetcher }, { method: "POST", body: JSON.stringify({ ids, patch }) }),
+        onSuccess: async () => {
+            await queryClient.invalidateQueries({ queryKey: queryKey() });
+        },
+    });
+    const batchDelete = useMutation({
+        mutationFn: async ({ ids }) => fetchWithValidation(`${basePath}/batch-delete`, batchDeleteEnvelope, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify({ ids }) }),
+        onSuccess: async () => {
+            await queryClient.invalidateQueries({ queryKey: queryKey() });
+        },
+    });
+    return { batchUpdate, batchDelete };
+}
+/** Batch mutations for `POST /v1/operations/availability/rules/{batch-update,batch-delete}`. */
+export function useAvailabilityRuleBatchMutation() {
+    return useAvailabilityBatchMutationPair("/v1/operations/availability/rules", availabilityRuleRecordSchema, availabilityQueryKeys.rules);
+}
+/** Batch mutations for `POST /v1/operations/availability/start-times/{batch-update,batch-delete}`. */
+export function useAvailabilityStartTimeBatchMutation() {
+    return useAvailabilityBatchMutationPair("/v1/operations/availability/start-times", availabilityStartTimeRecordSchema, availabilityQueryKeys.startTimes);
+}
+/** Batch mutations for `POST /v1/operations/availability/slots/{batch-update,batch-delete}`. */
+export function useAvailabilitySlotBatchMutation() {
+    return useAvailabilityBatchMutationPair("/v1/operations/availability/slots", availabilitySlotRecordSchema, availabilityQueryKeys.slots);
+}
+/** Batch mutations for `POST /v1/operations/availability/closeouts/{batch-update,batch-delete}`. */
+export function useAvailabilityCloseoutBatchMutation() {
+    return useAvailabilityBatchMutationPair("/v1/operations/availability/closeouts", availabilityCloseoutRecordSchema, availabilityQueryKeys.closeouts);
+}
+/** Batch mutations for `POST /v1/operations/availability/pickup-points/{batch-update,batch-delete}`. */
+export function useAvailabilityPickupPointBatchMutation() {
+    return useAvailabilityBatchMutationPair("/v1/operations/availability/pickup-points", availabilityPickupPointRecordSchema, availabilityQueryKeys.pickupPoints);
+}

package/dist/availability/hooks/use-availability-closeout-mutation.d.ts

@@ -0,0 +1,34 @@
+import { type UpdateAvailabilityCloseoutInput } from "../schemas.js";
+export declare function useAvailabilityCloseoutMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        slotId: string | null;
+        dateLocal: string;
+        reason: string | null;
+        createdBy: string | null;
+        productName?: string | null | undefined;
+    }, Error, {
+        productId: string;
+        dateLocal: string;
+        slotId?: string | null | undefined;
+        reason?: string | null | undefined;
+        createdBy?: string | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        slotId: string | null;
+        dateLocal: string;
+        reason: string | null;
+        createdBy: string | null;
+        productName?: string | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateAvailabilityCloseoutInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-availability-closeout-mutation.d.ts.map

package/dist/availability/hooks/use-availability-closeout-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-availability-closeout-mutation.d.ts","sourceRoot":"","sources":["../../../src/availability/hooks/use-availability-closeout-mutation.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,+BAA+B,EACrC,MAAM,eAAe,CAAA;AAEtB,wBAAgB,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;YAuBH,MAAM;eAAS,+BAA+B;;;;;EA4BzF"}

package/dist/availability/hooks/use-availability-closeout-mutation.js

@@ -0,0 +1,38 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantAvailabilityContext } from "../provider.js";
+import { availabilityQueryKeys } from "../query-keys.js";
+import { availabilityCloseoutSingleResponse, successEnvelope, } from "../schemas.js";
+export function useAvailabilityCloseoutMutation() {
+    const { baseUrl, fetcher } = useVoyantAvailabilityContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/operations/availability/closeouts", availabilityCloseoutSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: async (data) => {
+            await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.closeouts() });
+            await queryClient.invalidateQueries({
+                queryKey: availabilityQueryKeys.closeoutsList({ productId: data.productId }),
+            });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/operations/availability/closeouts/${id}`, availabilityCloseoutSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: async () => {
+            await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.closeouts() });
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/operations/availability/closeouts/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: async () => {
+            await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.closeouts() });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/availability/hooks/use-availability-overview.d.ts

@@ -0,0 +1,46 @@
+import type { AvailabilityOverviewFilters } from "../query-keys.js";
+export interface UseAvailabilityOverviewOptions extends AvailabilityOverviewFilters {
+    enabled?: boolean;
+}
+export declare function useAvailabilityOverview(options?: UseAvailabilityOverviewOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        openSlotsCount: number;
+        constrainedSlotsCount: number;
+        activeRulesCount: number;
+        activePickupPointsCount: number;
+        productsWithoutUpcomingDeparturesCount: number;
+        productsWithoutUpcomingDepartures: {
+            id: string;
+            name: string;
+            sellCurrency: string | null;
+            productType: {
+                id: string;
+                name: string;
+                code: string | null;
+            } | null;
+        }[];
+        constrainedSlots: {
+            id: string;
+            productId: string;
+            itineraryId: string | null;
+            optionId: string | null;
+            facilityId: string | null;
+            availabilityRuleId: string | null;
+            startTimeId: string | null;
+            dateLocal: string;
+            startsAt: string;
+            endsAt: string | null;
+            timezone: string;
+            status: "cancelled" | "open" | "closed" | "sold_out";
+            unlimited: boolean;
+            initialPax: number | null;
+            remainingPax: number | null;
+            nights: number | null;
+            days: number | null;
+            notes: string | null;
+            productName?: string | null | undefined;
+            endDateLocal?: string | null | undefined;
+        }[];
+    };
+}, Error>;
+//# sourceMappingURL=use-availability-overview.d.ts.map

package/dist/availability/hooks/use-availability-overview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-availability-overview.d.ts","sourceRoot":"","sources":["../../../src/availability/hooks/use-availability-overview.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAA;AAGnE,MAAM,WAAW,8BAA+B,SAAQ,2BAA2B;IACjF,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,8BAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAInF"}

package/dist/availability/hooks/use-availability-overview.js

@@ -0,0 +1,9 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantAvailabilityContext } from "../provider.js";
+import { getAvailabilityOverviewQueryOptions } from "../query-options.js";
+export function useAvailabilityOverview(options = {}) {
+    const client = useVoyantAvailabilityContext();
+    const { enabled = true } = options;
+    return useQuery({ ...getAvailabilityOverviewQueryOptions(client, options), enabled });
+}

package/dist/availability/hooks/use-availability-pickup-point-mutation.d.ts

@@ -0,0 +1,35 @@
+import { type UpdateAvailabilityPickupPointInput } from "../schemas.js";
+export declare function useAvailabilityPickupPointMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        name: string;
+        description: string | null;
+        locationText: string | null;
+        active: boolean;
+        productName?: string | null | undefined;
+    }, Error, {
+        productId: string;
+        name: string;
+        facilityId?: string | null | undefined;
+        description?: string | null | undefined;
+        locationText?: string | null | undefined;
+        active?: boolean | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        name: string;
+        description: string | null;
+        locationText: string | null;
+        active: boolean;
+        productName?: string | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateAvailabilityPickupPointInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-availability-pickup-point-mutation.d.ts.map

package/dist/availability/hooks/use-availability-pickup-point-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-availability-pickup-point-mutation.d.ts","sourceRoot":"","sources":["../../../src/availability/hooks/use-availability-pickup-point-mutation.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,kCAAkC,EACxC,MAAM,eAAe,CAAA;AAEtB,wBAAgB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;YA2BxC,MAAM;eACH,kCAAkC;;;;;EA6B9C"}

package/dist/availability/hooks/use-availability-pickup-point-mutation.js

@@ -0,0 +1,38 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantAvailabilityContext } from "../provider.js";
+import { availabilityQueryKeys } from "../query-keys.js";
+import { availabilityPickupPointSingleResponse, successEnvelope, } from "../schemas.js";
+export function useAvailabilityPickupPointMutation() {
+    const { baseUrl, fetcher } = useVoyantAvailabilityContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/operations/availability/pickup-points", availabilityPickupPointSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: async (data) => {
+            await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.pickupPoints() });
+            await queryClient.invalidateQueries({
+                queryKey: availabilityQueryKeys.pickupPointsList({ productId: data.productId }),
+            });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input, }) => {
+            const { data } = await fetchWithValidation(`/v1/operations/availability/pickup-points/${id}`, availabilityPickupPointSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: async () => {
+            await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.pickupPoints() });
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/operations/availability/pickup-points/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: async () => {
+            await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.pickupPoints() });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/availability/hooks/use-availability-rule-mutation.d.ts

@@ -0,0 +1,52 @@
+import { type UpdateAvailabilityRuleInput } from "../schemas.js";
+export declare function useAvailabilityRuleMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        optionId: string | null;
+        facilityId: string | null;
+        timezone: string;
+        recurrenceRule: string;
+        maxCapacity: number;
+        maxPickupCapacity: number | null;
+        minTotalPax: number | null;
+        cutoffMinutes: number | null;
+        earlyBookingLimitMinutes: number | null;
+        active: boolean;
+        productName?: string | null | undefined;
+    }, Error, {
+        productId: string;
+        timezone: string;
+        recurrenceRule: string;
+        maxCapacity: number;
+        optionId?: string | null | undefined;
+        facilityId?: string | null | undefined;
+        maxPickupCapacity?: number | null | undefined;
+        minTotalPax?: number | null | undefined;
+        cutoffMinutes?: number | null | undefined;
+        earlyBookingLimitMinutes?: number | null | undefined;
+        active?: boolean | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        optionId: string | null;
+        facilityId: string | null;
+        timezone: string;
+        recurrenceRule: string;
+        maxCapacity: number;
+        maxPickupCapacity: number | null;
+        minTotalPax: number | null;
+        cutoffMinutes: number | null;
+        earlyBookingLimitMinutes: number | null;
+        active: boolean;
+        productName?: string | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateAvailabilityRuleInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-availability-rule-mutation.d.ts.map

package/dist/availability/hooks/use-availability-rule-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-availability-rule-mutation.d.ts","sourceRoot":"","sources":["../../../src/availability/hooks/use-availability-rule-mutation.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,2BAA2B,EACjC,MAAM,eAAe,CAAA;AAEtB,wBAAgB,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAuBC,MAAM;eAAS,2BAA2B;;;;;EA+BrF"}

package/dist/availability/hooks/use-availability-rule-mutation.js

@@ -0,0 +1,41 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantAvailabilityContext } from "../provider.js";
+import { availabilityQueryKeys } from "../query-keys.js";
+import { availabilityRuleSingleResponse, successEnvelope, } from "../schemas.js";
+export function useAvailabilityRuleMutation() {
+    const { baseUrl, fetcher } = useVoyantAvailabilityContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/operations/availability/rules", availabilityRuleSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: async (data) => {
+            await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.rules() });
+            await queryClient.invalidateQueries({
+                queryKey: availabilityQueryKeys.rulesList({ productId: data.productId }),
+            });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/operations/availability/rules/${id}`, availabilityRuleSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: async (data) => {
+            await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.rules() });
+            await queryClient.invalidateQueries({
+                queryKey: availabilityQueryKeys.ruleDetail(data.id),
+            });
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/operations/availability/rules/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: async () => {
+            await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.rules() });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/availability/hooks/use-availability-slot-mutation.d.ts

@@ -0,0 +1,77 @@
+import { type UpdateAvailabilitySlotInput } from "../schemas.js";
+export declare function useAvailabilitySlotMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        itineraryId: string | null;
+        optionId: string | null;
+        facilityId: string | null;
+        availabilityRuleId: string | null;
+        startTimeId: string | null;
+        dateLocal: string;
+        startsAt: string;
+        endsAt: string | null;
+        timezone: string;
+        status: "cancelled" | "open" | "closed" | "sold_out";
+        unlimited: boolean;
+        initialPax: number | null;
+        remainingPax: number | null;
+        nights: number | null;
+        days: number | null;
+        notes: string | null;
+        productName?: string | null | undefined;
+        endDateLocal?: string | null | undefined;
+    }, Error, {
+        productId: string;
+        dateLocal: string;
+        startsAt: string;
+        timezone: string;
+        itineraryId?: string | null | undefined;
+        optionId?: string | null | undefined;
+        facilityId?: string | null | undefined;
+        availabilityRuleId?: string | null | undefined;
+        startTimeId?: string | null | undefined;
+        endsAt?: string | null | undefined;
+        status?: "cancelled" | "open" | "closed" | "sold_out" | undefined;
+        unlimited?: boolean | undefined;
+        initialPax?: number | null | undefined;
+        remainingPax?: number | null | undefined;
+        initialPickups?: number | null | undefined;
+        remainingPickups?: number | null | undefined;
+        remainingResources?: number | null | undefined;
+        pastCutoff?: boolean | undefined;
+        tooEarly?: boolean | undefined;
+        nights?: number | null | undefined;
+        days?: number | null | undefined;
+        notes?: string | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        itineraryId: string | null;
+        optionId: string | null;
+        facilityId: string | null;
+        availabilityRuleId: string | null;
+        startTimeId: string | null;
+        dateLocal: string;
+        startsAt: string;
+        endsAt: string | null;
+        timezone: string;
+        status: "cancelled" | "open" | "closed" | "sold_out";
+        unlimited: boolean;
+        initialPax: number | null;
+        remainingPax: number | null;
+        nights: number | null;
+        days: number | null;
+        notes: string | null;
+        productName?: string | null | undefined;
+        endDateLocal?: string | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateAvailabilitySlotInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-availability-slot-mutation.d.ts.map

package/dist/availability/hooks/use-availability-slot-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-availability-slot-mutation.d.ts","sourceRoot":"","sources":["../../../src/availability/hooks/use-availability-slot-mutation.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,2BAA2B,EACjC,MAAM,eAAe,CAAA;AAEtB,wBAAgB,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAuBC,MAAM;eAAS,2BAA2B;;;;;EA+BrF"}