@voyant-travel/inventory-react 0.1.0

package/dist/hooks/use-duplicate-product-option-mutation.js

@@ -0,0 +1,65 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantProductsContext } from "../provider.js";
+import { productsQueryKeys } from "../query-keys.js";
+import { optionUnitListResponse, productOptionSingleResponse, } from "../schemas.js";
+import { useOptionUnitMutation } from "./use-option-unit-mutation.js";
+import { useProductOptionMutation } from "./use-product-option-mutation.js";
+function defaultDuplicateName(name) {
+    return `${name} Copy`;
+}
+export function useDuplicateProductOptionMutation() {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const queryClient = useQueryClient();
+    const { create: createOption } = useProductOptionMutation();
+    const { create: createUnit } = useOptionUnitMutation();
+    return useMutation({
+        mutationFn: async ({ sourceOptionId, productId, name, code, description, status, isDefault, sortOrder, availableFrom, availableTo, }) => {
+            const [{ data: sourceOption }, { data: sourceUnits }] = await Promise.all([
+                fetchWithValidation(`/v1/products/options/${sourceOptionId}`, productOptionSingleResponse, {
+                    baseUrl,
+                    fetcher,
+                }),
+                fetchWithValidation(`/v1/products/option-units?optionId=${encodeURIComponent(sourceOptionId)}&limit=100`, optionUnitListResponse, { baseUrl, fetcher }),
+            ]);
+            const duplicatedOption = await createOption.mutateAsync({
+                productId: productId ?? sourceOption.productId,
+                name: name ?? defaultDuplicateName(sourceOption.name),
+                code: code === undefined ? null : code,
+                description: description ?? sourceOption.description,
+                status: status ?? sourceOption.status,
+                isDefault: isDefault ?? false,
+                sortOrder: sortOrder ?? sourceOption.sortOrder + 1,
+                availableFrom: availableFrom ?? sourceOption.availableFrom,
+                availableTo: availableTo ?? sourceOption.availableTo,
+            });
+            const unitIdMap = {};
+            for (const unit of [...sourceUnits].sort((a, b) => a.sortOrder - b.sortOrder)) {
+                const duplicatedUnit = await createUnit.mutateAsync({
+                    optionId: duplicatedOption.id,
+                    name: unit.name,
+                    code: unit.code,
+                    description: unit.description,
+                    unitType: unit.unitType,
+                    minQuantity: unit.minQuantity,
+                    maxQuantity: unit.maxQuantity,
+                    minAge: unit.minAge,
+                    maxAge: unit.maxAge,
+                    occupancyMin: unit.occupancyMin,
+                    occupancyMax: unit.occupancyMax,
+                    isRequired: unit.isRequired,
+                    isHidden: unit.isHidden,
+                    sortOrder: unit.sortOrder,
+                });
+                unitIdMap[unit.id] = duplicatedUnit.id;
+            }
+            return { option: duplicatedOption, unitIdMap };
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.productOptions() });
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.optionUnits() });
+            queryClient.setQueryData(productsQueryKeys.productOption(data.option.id), data.option);
+        },
+    });
+}

package/dist/hooks/use-option-unit-mutation.d.ts

@@ -0,0 +1,60 @@
+export interface CreateOptionUnitInput {
+    optionId: string;
+    name: string;
+    code?: string | null;
+    description?: string | null;
+    unitType?: "person" | "group" | "room" | "vehicle" | "service" | "other";
+    minQuantity?: number | null;
+    maxQuantity?: number | null;
+    minAge?: number | null;
+    maxAge?: number | null;
+    occupancyMin?: number | null;
+    occupancyMax?: number | null;
+    isRequired?: boolean;
+    isHidden?: boolean;
+    sortOrder?: number;
+}
+export type UpdateOptionUnitInput = Omit<Partial<CreateOptionUnitInput>, "optionId">;
+export declare function useOptionUnitMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        optionId: string;
+        name: string;
+        code: string | null;
+        description: string | null;
+        unitType: "person" | "group" | "room" | "vehicle" | "service" | "other";
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        minAge: number | null;
+        maxAge: number | null;
+        occupancyMin: number | null;
+        occupancyMax: number | null;
+        isRequired: boolean;
+        isHidden: boolean;
+        sortOrder: number;
+    }, Error, CreateOptionUnitInput, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        optionId: string;
+        name: string;
+        code: string | null;
+        description: string | null;
+        unitType: "person" | "group" | "room" | "vehicle" | "service" | "other";
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        minAge: number | null;
+        maxAge: number | null;
+        occupancyMin: number | null;
+        occupancyMax: number | null;
+        isRequired: boolean;
+        isHidden: boolean;
+        sortOrder: number;
+    }, Error, {
+        id: string;
+        input: UpdateOptionUnitInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-option-unit-mutation.d.ts.map

package/dist/hooks/use-option-unit-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-unit-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-unit-mutation.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;IACxE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,OAAO,CAAC,qBAAqB,CAAC,EAAE,UAAU,CAAC,CAAA;AAIpF,wBAAgB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAuBO,MAAM;eAAS,qBAAqB;;;;;EA6B/E"}

package/dist/hooks/use-option-unit-mutation.js

@@ -0,0 +1,41 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { z } from "zod";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantProductsContext } from "../provider.js";
+import { productsQueryKeys } from "../query-keys.js";
+import { optionUnitSingleResponse } from "../schemas.js";
+const deleteResponseSchema = z.object({ success: z.boolean() });
+export function useOptionUnitMutation() {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async ({ optionId, ...input }) => {
+            const { data } = await fetchWithValidation(`/v1/products/options/${optionId}/units`, optionUnitSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.optionUnits() });
+            void queryClient.invalidateQueries({
+                queryKey: productsQueryKeys.productOption(data.optionId),
+            });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/products/units/${id}`, optionUnitSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.optionUnits() });
+            queryClient.setQueryData(productsQueryKeys.optionUnit(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/products/units/${id}`, deleteResponseSchema, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.optionUnits() });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-option-unit.d.ts

@@ -0,0 +1,21 @@
+export interface UseOptionUnitOptions {
+    enabled?: boolean;
+}
+export declare function useOptionUnit(id: string | undefined, options?: UseOptionUnitOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    optionId: string;
+    name: string;
+    code: string | null;
+    description: string | null;
+    unitType: "person" | "group" | "room" | "vehicle" | "service" | "other";
+    minQuantity: number | null;
+    maxQuantity: number | null;
+    minAge: number | null;
+    maxAge: number | null;
+    occupancyMin: number | null;
+    occupancyMax: number | null;
+    isRequired: boolean;
+    isHidden: boolean;
+    sortOrder: number;
+}, Error>;
+//# sourceMappingURL=use-option-unit.d.ts.map

package/dist/hooks/use-option-unit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-unit.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-unit.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,GAAE,oBAAyB;;;;;;;;;;;;;;;;UAQvF"}

package/dist/hooks/use-option-unit.js

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantProductsContext } from "../provider.js";
+import { getOptionUnitQueryOptions } from "../query-options.js";
+export function useOptionUnit(id, options = {}) {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getOptionUnitQueryOptions({ baseUrl, fetcher }, id, options),
+        enabled: enabled && !!id,
+    });
+}

package/dist/hooks/use-option-units.d.ts

@@ -0,0 +1,27 @@
+import type { OptionUnitsListFilters } from "../query-keys.js";
+export interface UseOptionUnitsOptions extends OptionUnitsListFilters {
+    enabled?: boolean;
+}
+export declare function useOptionUnits(options?: UseOptionUnitsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        optionId: string;
+        name: string;
+        code: string | null;
+        description: string | null;
+        unitType: "person" | "group" | "room" | "vehicle" | "service" | "other";
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        minAge: number | null;
+        maxAge: number | null;
+        occupancyMin: number | null;
+        occupancyMax: number | null;
+        isRequired: boolean;
+        isHidden: boolean;
+        sortOrder: number;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-option-units.d.ts.map

package/dist/hooks/use-option-units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-units.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-units.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAA;AAG9D,MAAM,WAAW,qBAAsB,SAAQ,sBAAsB;IACnE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B;;;;;;;;;;;;;;;;;;;;;UAQjE"}

package/dist/hooks/use-option-units.js

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantProductsContext } from "../provider.js";
+import { getOptionUnitsQueryOptions } from "../query-options.js";
+export function useOptionUnits(options = {}) {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const { enabled = true, ...filters } = options;
+    return useQuery({
+        ...getOptionUnitsQueryOptions({ baseUrl, fetcher }, filters),
+        enabled,
+    });
+}

package/dist/hooks/use-product-action-ledger.d.ts

@@ -0,0 +1,48 @@
+import { type UseProductActionLedgerOptions } from "../query-options-action-ledger.js";
+export declare function useProductActionLedger(productId: string | null | undefined, options?: UseProductActionLedgerOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        occurredAt: string;
+        actionName: string;
+        actionVersion: string;
+        actionKind: "read" | "create" | "update" | "delete" | "execute" | "approve" | "reject" | "reverse" | "compensate" | "duplicate";
+        status: "requested" | "awaiting_approval" | "approved" | "denied" | "succeeded" | "failed" | "reversed" | "compensated" | "expired" | "cancelled" | "superseded";
+        evaluatedRisk: "low" | "medium" | "high" | "critical";
+        actorType: string | null;
+        principalType: "user" | "api_key" | "agent" | "workflow" | "system";
+        principalId: string;
+        principalSubtype: string | null;
+        sessionId: string | null;
+        apiTokenId: string | null;
+        internalRequest: boolean;
+        delegatedByPrincipalType: "user" | "api_key" | "agent" | "workflow" | "system" | null;
+        delegatedByPrincipalId: string | null;
+        delegationId: string | null;
+        callerType: string | null;
+        organizationId: string | null;
+        routeOrToolName: string | null;
+        workflowRunId: string | null;
+        workflowStepId: string | null;
+        correlationId: string | null;
+        causationActionId: string | null;
+        idempotencyScope: string | null;
+        idempotencyKey: string | null;
+        idempotencyFingerprint: string | null;
+        targetType: string;
+        targetId: string;
+        capabilityId: string | null;
+        capabilityVersion: string | null;
+        authorizationSource: string | null;
+        approvalId: string | null;
+        amendsActionId: string | null;
+        createdAt: string;
+        mutationSummary: string | null;
+    }[];
+    pageInfo: {
+        nextCursor: {
+            occurredAt: string;
+            id: string;
+        } | null;
+    };
+}, Error>;
+//# sourceMappingURL=use-product-action-ledger.d.ts.map

package/dist/hooks/use-product-action-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-action-ledger.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-action-ledger.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,6BAA6B,EACnC,MAAM,mCAAmC,CAAA;AAE1C,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,OAAO,GAAE,6BAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAS5C"}

package/dist/hooks/use-product-action-ledger.js

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantProductsContext } from "../provider.js";
+import { getProductActionLedgerQueryOptions, } from "../query-options-action-ledger.js";
+export function useProductActionLedger(productId, options = {}) {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getProductActionLedgerQueryOptions({ baseUrl, fetcher }, productId, options),
+        enabled: enabled && Boolean(productId),
+    });
+}

package/dist/hooks/use-product-categories.d.ts

@@ -0,0 +1,32 @@
+import { type ProductCategoriesListFilters } from "../query-keys.js";
+export interface UseProductCategoriesOptions extends ProductCategoriesListFilters {
+    enabled?: boolean;
+}
+export declare function useProductCategories(options?: UseProductCategoriesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        parentId: string | null;
+        name: string;
+        slug: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        createdAt: string;
+        updatedAt: string;
+        customerPaymentPolicy?: {
+            deposit: {
+                kind: "none" | "percent" | "fixed_cents";
+                percent?: number | undefined;
+                amountCents?: number | undefined;
+            };
+            minDaysBeforeDepartureForDeposit: number;
+            balanceDueDaysBeforeDeparture: number;
+            balanceDueMinDaysFromNow: number;
+        } | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-product-categories.d.ts.map

package/dist/hooks/use-product-categories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-categories.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-categories.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,4BAA4B,EAAqB,MAAM,kBAAkB,CAAA;AAGvF,MAAM,WAAW,2BAA4B,SAAQ,4BAA4B;IAC/E,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,2BAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;UAsB7E"}

package/dist/hooks/use-product-categories.js

@@ -0,0 +1,29 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantProductsContext } from "../provider.js";
+import { productsQueryKeys } from "../query-keys.js";
+import { productCategoryListResponse } from "../schemas.js";
+export function useProductCategories(options = {}) {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const { enabled = true, ...filters } = options;
+    return useQuery({
+        queryKey: productsQueryKeys.productCategoriesList(filters),
+        queryFn: () => {
+            const params = new URLSearchParams();
+            if (filters.parentId)
+                params.set("parentId", filters.parentId);
+            if (filters.active !== undefined)
+                params.set("active", String(filters.active));
+            if (filters.search)
+                params.set("search", filters.search);
+            if (filters.limit !== undefined)
+                params.set("limit", String(filters.limit));
+            if (filters.offset !== undefined)
+                params.set("offset", String(filters.offset));
+            const qs = params.toString();
+            return fetchWithValidation(`/v1/products/product-categories${qs ? `?${qs}` : ""}`, productCategoryListResponse, { baseUrl, fetcher });
+        },
+        enabled,
+    });
+}

package/dist/hooks/use-product-category-mutation.d.ts

@@ -0,0 +1,65 @@
+import { type ProductCategoryPaymentPolicy } from "../schemas.js";
+export interface CreateProductCategoryInput {
+    name: string;
+    slug: string;
+    parentId?: string | null;
+    description?: string | null;
+    sortOrder?: number;
+    active?: boolean;
+    customerPaymentPolicy?: ProductCategoryPaymentPolicy | null;
+    metadata?: Record<string, unknown> | null;
+}
+export type UpdateProductCategoryInput = Partial<CreateProductCategoryInput>;
+export declare function useProductCategoryMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        parentId: string | null;
+        name: string;
+        slug: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        createdAt: string;
+        updatedAt: string;
+        customerPaymentPolicy?: {
+            deposit: {
+                kind: "none" | "percent" | "fixed_cents";
+                percent?: number | undefined;
+                amountCents?: number | undefined;
+            };
+            minDaysBeforeDepartureForDeposit: number;
+            balanceDueDaysBeforeDeparture: number;
+            balanceDueMinDaysFromNow: number;
+        } | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, CreateProductCategoryInput, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        parentId: string | null;
+        name: string;
+        slug: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        createdAt: string;
+        updatedAt: string;
+        customerPaymentPolicy?: {
+            deposit: {
+                kind: "none" | "percent" | "fixed_cents";
+                percent?: number | undefined;
+                amountCents?: number | undefined;
+            };
+            minDaysBeforeDepartureForDeposit: number;
+            balanceDueDaysBeforeDeparture: number;
+            balanceDueMinDaysFromNow: number;
+        } | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateProductCategoryInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-product-category-mutation.d.ts.map

package/dist/hooks/use-product-category-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-category-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-category-mutation.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,4BAA4B,EAAiC,MAAM,eAAe,CAAA;AAEhG,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,qBAAqB,CAAC,EAAE,4BAA4B,GAAG,IAAI,CAAA;IAC3D,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;CAC1C;AAED,MAAM,MAAM,0BAA0B,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAA;AAI5E,wBAAgB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAoBE,MAAM;eAAS,0BAA0B;;;;;EA8BpF"}

package/dist/hooks/use-product-category-mutation.js

@@ -0,0 +1,39 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { z } from "zod";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantProductsContext } from "../provider.js";
+import { productsQueryKeys } from "../query-keys.js";
+import { productCategorySingleResponse } from "../schemas.js";
+const deleteResponseSchema = z.object({ success: z.boolean() });
+export function useProductCategoryMutation() {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/products/product-categories", productCategorySingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.productCategories() });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/products/product-categories/${id}`, productCategorySingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.productCategories() });
+            queryClient.setQueryData(productsQueryKeys.productCategory(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/products/product-categories/${id}`, deleteResponseSchema, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.productCategories() });
+            queryClient.removeQueries({ queryKey: productsQueryKeys.productCategory(id) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-product-category.d.ts

@@ -0,0 +1,26 @@
+export interface UseProductCategoryOptions {
+    enabled?: boolean;
+}
+export declare function useProductCategory(id: string | null | undefined, options?: UseProductCategoryOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    parentId: string | null;
+    name: string;
+    slug: string;
+    description: string | null;
+    sortOrder: number;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+    customerPaymentPolicy?: {
+        deposit: {
+            kind: "none" | "percent" | "fixed_cents";
+            percent?: number | undefined;
+            amountCents?: number | undefined;
+        };
+        minDaysBeforeDepartureForDeposit: number;
+        balanceDueDaysBeforeDeparture: number;
+        balanceDueMinDaysFromNow: number;
+    } | null | undefined;
+    metadata?: Record<string, unknown> | null | undefined;
+}, Error>;
+//# sourceMappingURL=use-product-category.d.ts.map

package/dist/hooks/use-product-category.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-category.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-category.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,yBAAyB;IACxC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7B,OAAO,GAAE,yBAA8B;;;;;;;;;;;;;;;;;;;;;UAiBxC"}

package/dist/hooks/use-product-category.js

@@ -0,0 +1,18 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantProductsContext } from "../provider.js";
+import { productsQueryKeys } from "../query-keys.js";
+import { productCategorySingleResponse } from "../schemas.js";
+export function useProductCategory(id, options = {}) {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const { enabled = true } = options;
+    return useQuery({
+        queryKey: productsQueryKeys.productCategory(id ?? "__missing__"),
+        queryFn: async () => {
+            const { data } = await fetchWithValidation(`/v1/products/product-categories/${id}`, productCategorySingleResponse, { baseUrl, fetcher });
+            return data;
+        },
+        enabled: enabled && Boolean(id),
+    });
+}

package/dist/hooks/use-product-day-mutation.d.ts

@@ -0,0 +1,43 @@
+import { type UpdateProductDayInput } from "../schemas.js";
+export declare function useProductDayMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        itineraryId: string;
+        dayNumber: number;
+        title: string | null;
+        description: string | null;
+        location: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        dayNumber: number;
+        title?: string | null | undefined;
+        description?: string | null | undefined;
+        location?: string | null | undefined;
+    } & {
+        productId: string;
+        itineraryId?: string;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        itineraryId: string;
+        dayNumber: number;
+        title: string | null;
+        description: string | null;
+        location: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        productId: string;
+        dayId: string;
+        input: UpdateProductDayInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, {
+        productId: string;
+        dayId: string;
+        itineraryId?: string;
+    }, unknown>;
+};
+//# sourceMappingURL=use-product-day-mutation.d.ts.map

package/dist/hooks/use-product-day-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-day-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-day-mutation.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,eAAe,CAAA;AAEtB,wBAAgB,qBAAqB;;;;;;;;;;;;;;;;mBASO,MAAM;sBAAgB,MAAM;;;;;;;;;;;;mBA2BvD,MAAM;eACV,MAAM;eACN,qBAAqB;;;;;mBAyBjB,MAAM;eACV,MAAM;sBACC,MAAM;;EAwBzB"}

package/dist/hooks/use-product-day-mutation.js

@@ -0,0 +1,54 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantProductsContext } from "../provider.js";
+import { productsQueryKeys } from "../query-keys.js";
+import { productDayResponse, successEnvelope, } from "../schemas.js";
+export function useProductDayMutation() {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async ({ productId, itineraryId, ...input }) => {
+            const { data } = await fetchWithValidation(itineraryId
+                ? `/v1/products/${productId}/itineraries/${itineraryId}/days`
+                : `/v1/products/${productId}/days`, productDayResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: async (data, variables) => {
+            await queryClient.invalidateQueries({
+                queryKey: productsQueryKeys.productDays(variables.productId),
+            });
+            await queryClient.invalidateQueries({
+                queryKey: productsQueryKeys.productItineraryDays(variables.productId, data.itineraryId),
+            });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ productId, dayId, input, }) => {
+            const { data } = await fetchWithValidation(`/v1/products/${productId}/days/${dayId}`, productDayResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: async (data, variables) => {
+            await queryClient.invalidateQueries({
+                queryKey: productsQueryKeys.productDays(variables.productId),
+            });
+            await queryClient.invalidateQueries({
+                queryKey: productsQueryKeys.productItineraryDays(variables.productId, data.itineraryId),
+            });
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async ({ productId, dayId, }) => fetchWithValidation(`/v1/products/${productId}/days/${dayId}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: async (_data, variables) => {
+            await queryClient.invalidateQueries({
+                queryKey: productsQueryKeys.productDays(variables.productId),
+            });
+            if (variables.itineraryId) {
+                await queryClient.invalidateQueries({
+                    queryKey: productsQueryKeys.productItineraryDays(variables.productId, variables.itineraryId),
+                });
+            }
+        },
+    });
+    return { create, update, remove };
+}