@voyant-travel/operations-react 0.0.0

package/dist/availability/hooks/use-slot-allocation.js

@@ -0,0 +1,211 @@
+"use client";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { z } from "zod";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantAvailabilityContext } from "../provider.js";
+import { availabilityQueryKeys } from "../query-keys.js";
+import { getProductResourceTemplatesQueryOptions, getSlotAllocationAuditLogQueryOptions, getSlotAllocationQueryOptions, } from "../query-options.js";
+import { allocationAutomationResponse, allocationResourceSchema, resourceTemplateSchema, sharingGroupLabelSchema, singleEnvelope, } from "../schemas.js";
+const assignTravelerAllocationResponse = singleEnvelope(z.object({
+    travelerId: z.string(),
+    kind: z.string(),
+    resourceId: z.string().nullable(),
+}));
+const updateTravelerSharingGroupResponse = singleEnvelope(z.object({
+    travelerId: z.string(),
+    sharingGroupId: z.string().nullable(),
+}));
+const pairSharingGroupResponse = singleEnvelope(z.object({
+    sharingGroupId: z.string(),
+    travelerIds: z.array(z.string()),
+}));
+export function useSlotAllocation({ slotId, enabled = true }) {
+    const client = useVoyantAvailabilityContext();
+    return useQuery({
+        ...getSlotAllocationQueryOptions(client, slotId),
+        enabled: enabled && Boolean(slotId),
+    });
+}
+export function useSlotAllocationAuditLog({ slotId, enabled = true }) {
+    const client = useVoyantAvailabilityContext();
+    return useQuery({
+        ...getSlotAllocationAuditLogQueryOptions(client, slotId),
+        enabled: enabled && Boolean(slotId),
+    });
+}
+export function useProductResourceTemplates({ productId, enabled = true, }) {
+    const client = useVoyantAvailabilityContext();
+    return useQuery({
+        ...getProductResourceTemplatesQueryOptions(client, productId),
+        enabled: enabled && Boolean(productId),
+    });
+}
+export function useAllocationResourceMutation(slotId) {
+    const { baseUrl, fetcher } = useVoyantAvailabilityContext();
+    const queryClient = useQueryClient();
+    const invalidate = async () => {
+        await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.slotAllocation(slotId) });
+        await queryClient.invalidateQueries({
+            queryKey: availabilityQueryKeys.slotAllocationAuditLog(slotId),
+        });
+    };
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation(`/v1/admin/operations/${slotId}/allocation/operations`, singleEnvelope(allocationResourceSchema), { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: invalidate,
+    });
+    const update = useMutation({
+        mutationFn: async ({ resourceId, input, }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/operations/${slotId}/allocation/operations/${resourceId}`, singleEnvelope(allocationResourceSchema), { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: invalidate,
+    });
+    const remove = useMutation({
+        mutationFn: async (resourceId) => fetchWithValidation(`/v1/admin/operations/${slotId}/allocation/operations/${resourceId}`, singleEnvelope(allocationResourceSchema.pick({ id: true })), { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: invalidate,
+    });
+    return { create, update, remove };
+}
+export function useResourceTemplateMutation(productId) {
+    const { baseUrl, fetcher } = useVoyantAvailabilityContext();
+    const queryClient = useQueryClient();
+    const invalidate = async () => {
+        await queryClient.invalidateQueries({
+            queryKey: availabilityQueryKeys.productResourceTemplates(productId),
+        });
+    };
+    const upsert = useMutation({
+        mutationFn: async ({ optionId, kind, input, }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/operations/${productId}/options/${optionId}/allocation/resource-templates/${kind}`, singleEnvelope(resourceTemplateSchema), { baseUrl, fetcher }, { method: "PUT", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: invalidate,
+    });
+    const remove = useMutation({
+        // refId targets a single template when an option holds several of the same
+        // kind (e.g. one "room" per option_unit); omit it for ref-less templates.
+        mutationFn: async ({ optionId, kind, refId, }) => fetchWithValidation(`/v1/admin/operations/${productId}/options/${optionId}/allocation/resource-templates/${kind}${refId ? `?refId=${encodeURIComponent(refId)}` : ""}`, singleEnvelope(z.object({ productOptionId: z.string(), kind: z.string() })), { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: invalidate,
+    });
+    return { upsert, remove };
+}
+/**
+ * Back-fill resources across a product's open future departures from the
+ * option's templates (idempotent — slots that already have a kind are skipped).
+ * Lets an operator apply newly-configured departure inventory to slots that
+ * already exist, not just future ones.
+ */
+export function useMaterializeOpenSlotsMutation(productId) {
+    const { baseUrl, fetcher } = useVoyantAvailabilityContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (input) => {
+            const result = await fetchWithValidation(`/v1/admin/operations/${productId}/allocation/materialize-open-slots`, singleEnvelope(z.object({ slots: z.number(), created: z.number() })), { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return result.data;
+        },
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.slots() });
+        },
+    });
+}
+export function useAllocationAutomationMutation(slotId) {
+    const { baseUrl, fetcher } = useVoyantAvailabilityContext();
+    const queryClient = useQueryClient();
+    const invalidate = async () => {
+        await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.slotAllocation(slotId) });
+        await queryClient.invalidateQueries({
+            queryKey: availabilityQueryKeys.slotAllocationAuditLog(slotId),
+        });
+    };
+    const autoMaterialize = useMutation({
+        mutationFn: async (input) => {
+            const result = await fetchWithValidation(`/v1/admin/operations/${slotId}/allocation/auto-materialize`, allocationAutomationResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return result.data;
+        },
+        onSuccess: invalidate,
+    });
+    const autoAllocate = useMutation({
+        mutationFn: async (input) => {
+            const result = await fetchWithValidation(`/v1/admin/operations/${slotId}/allocation/auto-allocate`, allocationAutomationResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return result.data;
+        },
+        onSuccess: invalidate,
+    });
+    // Materialize the slot's full configured inventory (all kinds, from template
+    // default_count) in one call — distinct from the pax-derived autoMaterialize.
+    const materializeTemplates = useMutation({
+        mutationFn: async () => {
+            const result = await fetchWithValidation(`/v1/admin/operations/${slotId}/allocation/materialize-templates`, singleEnvelope(z.object({ created: z.number() })), { baseUrl, fetcher }, { method: "POST", body: JSON.stringify({}) });
+            return result.data;
+        },
+        onSuccess: invalidate,
+    });
+    return { autoMaterialize, autoAllocate, materializeTemplates };
+}
+export function useAssignTravelerAllocationMutation(slotId) {
+    const { baseUrl, fetcher } = useVoyantAvailabilityContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => fetchWithValidation(`/v1/admin/operations/${slotId}/allocation/travelers/${input.travelerId}`, assignTravelerAllocationResponse, { baseUrl, fetcher }, {
+            method: "PATCH",
+            body: JSON.stringify({ kind: input.kind, resourceId: input.resourceId }),
+        }),
+        onSuccess: async () => {
+            await queryClient.invalidateQueries({
+                queryKey: availabilityQueryKeys.slotAllocation(slotId),
+            });
+            await queryClient.invalidateQueries({
+                queryKey: availabilityQueryKeys.slotAllocationAuditLog(slotId),
+            });
+        },
+    });
+}
+export function useSharingGroupLabelMutation(slotId) {
+    const { baseUrl, fetcher } = useVoyantAvailabilityContext();
+    const queryClient = useQueryClient();
+    const invalidate = async () => {
+        await queryClient.invalidateQueries({ queryKey: availabilityQueryKeys.slotAllocation(slotId) });
+        await queryClient.invalidateQueries({
+            queryKey: availabilityQueryKeys.slotAllocationAuditLog(slotId),
+        });
+    };
+    const update = useMutation({
+        mutationFn: (input) => fetchWithValidation(`/v1/admin/operations/${slotId}/allocation/sharing-groups/${input.groupId}/label`, singleEnvelope(sharingGroupLabelSchema), { baseUrl, fetcher }, { method: "PUT", body: JSON.stringify({ label: input.label }) }),
+        onSuccess: invalidate,
+    });
+    const remove = useMutation({
+        mutationFn: (groupId) => fetchWithValidation(`/v1/admin/operations/${slotId}/allocation/sharing-groups/${groupId}/label`, singleEnvelope(sharingGroupLabelSchema), { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: invalidate,
+    });
+    return { update, remove };
+}
+export function useTravelerSharingGroupMutation(slotId) {
+    const { baseUrl, fetcher } = useVoyantAvailabilityContext();
+    const queryClient = useQueryClient();
+    const update = useMutation({
+        mutationFn: (input) => fetchWithValidation(`/v1/admin/operations/${slotId}/allocation/travelers/${input.travelerId}/sharing-group`, updateTravelerSharingGroupResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify({ sharingGroupId: input.sharingGroupId }) }),
+        onSuccess: async () => {
+            await queryClient.invalidateQueries({
+                queryKey: availabilityQueryKeys.slotAllocation(slotId),
+            });
+            await queryClient.invalidateQueries({
+                queryKey: availabilityQueryKeys.slotAllocationAuditLog(slotId),
+            });
+        },
+    });
+    const pair = useMutation({
+        mutationFn: (input) => fetchWithValidation(`/v1/admin/operations/${slotId}/allocation/sharing-groups/pair`, pairSharingGroupResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) }),
+        onSuccess: async () => {
+            await queryClient.invalidateQueries({
+                queryKey: availabilityQueryKeys.slotAllocation(slotId),
+            });
+            await queryClient.invalidateQueries({
+                queryKey: availabilityQueryKeys.slotAllocationAuditLog(slotId),
+            });
+        },
+    });
+    return { update, pair };
+}

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

@@ -0,0 +1,25 @@
+export interface UseSlotUnitAvailabilityOptions {
+    slotId: string | null | undefined;
+    enabled?: boolean;
+}
+/**
+ * Per-option-unit availability for a slot. Returns one row per `option_unit`
+ * on the slot's option, with `initial` (from `option_units.max_quantity`),
+ * `reserved` (sum of active bookings' item quantity for this slot + unit),
+ * and `remaining = initial - reserved` (or `null` when the pool is
+ * unlimited).
+ *
+ * Active booking statuses counted: draft, on_hold, confirmed, in_progress,
+ * completed. cancelled + expired are excluded.
+ */
+export declare function useSlotUnitAvailability({ slotId, enabled, }: UseSlotUnitAvailabilityOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        optionUnitId: string;
+        unitName: string;
+        occupancyMax: number | null;
+        initial: number | null;
+        reserved: number;
+        remaining: number | null;
+    }[];
+}, Error>;
+//# sourceMappingURL=use-slot-unit-availability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-slot-unit-availability.d.ts","sourceRoot":"","sources":["../../../src/availability/hooks/use-slot-unit-availability.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,8BAA8B;IAC7C,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;IACjC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,MAAM,EACN,OAAc,GACf,EAAE,8BAA8B;;;;;;;;;UAMhC"}

package/dist/availability/hooks/use-slot-unit-availability.js

@@ -0,0 +1,21 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantAvailabilityContext } from "../provider.js";
+import { getSlotUnitAvailabilityQueryOptions } from "../query-options.js";
+/**
+ * Per-option-unit availability for a slot. Returns one row per `option_unit`
+ * on the slot's option, with `initial` (from `option_units.max_quantity`),
+ * `reserved` (sum of active bookings' item quantity for this slot + unit),
+ * and `remaining = initial - reserved` (or `null` when the pool is
+ * unlimited).
+ *
+ * Active booking statuses counted: draft, on_hold, confirmed, in_progress,
+ * completed. cancelled + expired are excluded.
+ */
+export function useSlotUnitAvailability({ slotId, enabled = true, }) {
+    const client = useVoyantAvailabilityContext();
+    return useQuery({
+        ...getSlotUnitAvailabilityQueryOptions(client, slotId),
+        enabled: enabled && Boolean(slotId),
+    });
+}

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

@@ -0,0 +1,32 @@
+import type { AvailabilitySlotsListFilters } from "../query-keys.js";
+export interface UseSlotsOptions extends AvailabilitySlotsListFilters {
+    enabled?: boolean;
+}
+export declare function useSlots(options?: UseSlotsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        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;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-slots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-slots.d.ts","sourceRoot":"","sources":["../../../src/availability/hooks/use-slots.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAA;AAGpE,MAAM,WAAW,eAAgB,SAAQ,4BAA4B;IACnE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,QAAQ,CAAC,OAAO,GAAE,eAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;UAIrD"}

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

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

package/dist/availability/hooks/use-start-times.d.ts

@@ -0,0 +1,22 @@
+import type { AvailabilityStartTimesListFilters } from "../query-keys.js";
+export interface UseStartTimesOptions extends AvailabilityStartTimesListFilters {
+    enabled?: boolean;
+}
+export declare function useStartTimes(options?: UseStartTimesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        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;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-start-times.d.ts.map

package/dist/availability/hooks/use-start-times.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-start-times.d.ts","sourceRoot":"","sources":["../../../src/availability/hooks/use-start-times.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,kBAAkB,CAAA;AAGzE,MAAM,WAAW,oBAAqB,SAAQ,iCAAiC;IAC7E,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB;;;;;;;;;;;;;;;;UAI/D"}

package/dist/availability/hooks/use-start-times.js

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

package/dist/availability/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export { type AvailabilityUiMessageOverrides, type AvailabilityUiMessages, AvailabilityUiMessagesProvider, availabilityUiEn, availabilityUiMessageDefinitions, availabilityUiRo, getAvailabilityUiI18n, resolveAvailabilityUiMessages, useAvailabilityUiI18n, useAvailabilityUiI18nOrDefault, useAvailabilityUiMessages, useAvailabilityUiMessagesOrDefault, } from "./provider.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/availability/i18n/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/availability/i18n/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,sBAAsB,EAC3B,8BAA8B,EAC9B,gBAAgB,EAChB,gCAAgC,EAChC,gBAAgB,EAChB,qBAAqB,EACrB,6BAA6B,EAC7B,qBAAqB,EACrB,8BAA8B,EAC9B,yBAAyB,EACzB,kCAAkC,GACnC,MAAM,eAAe,CAAA"}

package/dist/availability/i18n/index.js

@@ -0,0 +1 @@
+export { AvailabilityUiMessagesProvider, availabilityUiEn, availabilityUiMessageDefinitions, availabilityUiRo, getAvailabilityUiI18n, resolveAvailabilityUiMessages, useAvailabilityUiI18n, useAvailabilityUiI18nOrDefault, useAvailabilityUiMessages, useAvailabilityUiMessagesOrDefault, } from "./provider.js";