@voyant-travel/inventory-react 0.1.0

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

@@ -0,0 +1,52 @@
+import { type CreateProductTranslationInput, type UpdateProductTranslationInput } from "../schemas.js";
+export declare function useProductTranslationMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        languageTag: string;
+        slug: string | null;
+        name: string;
+        shortDescription: string | null;
+        description: string | null;
+        inclusionsHtml: string | null;
+        exclusionsHtml: string | null;
+        termsHtml: string | null;
+        seoTitle: string | null;
+        seoDescription: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        productId: string;
+        input: CreateProductTranslationInput;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        productId: string;
+        translation: {
+            id: string;
+            productId: string;
+            languageTag: string;
+            slug: string | null;
+            name: string;
+            shortDescription: string | null;
+            description: string | null;
+            inclusionsHtml: string | null;
+            exclusionsHtml: string | null;
+            termsHtml: string | null;
+            seoTitle: string | null;
+            seoDescription: string | null;
+            createdAt: string;
+            updatedAt: string;
+        };
+    }, Error, {
+        productId: string;
+        translationId: string;
+        input: UpdateProductTranslationInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        productId: string;
+    }, Error, {
+        productId: string;
+        translationId: string;
+    }, unknown>;
+};
+//# sourceMappingURL=use-product-translation-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-translation-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-translation-mutation.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,6BAA6B,EAGlC,KAAK,6BAA6B,EACnC,MAAM,eAAe,CAAA;AAEtB,wBAAgB,6BAA6B;;;;;;;;;;;;;;;;;mBAS5B,MAAM;eACV,6BAA6B;;;;;;;;;;;;;;;;;;;;;mBAwBzB,MAAM;uBACF,MAAM;eACd,6BAA6B;;;;;mBAuBzB,MAAM;uBACF,MAAM;;EAmB1B"}

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

@@ -0,0 +1,47 @@
+"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 { productTranslationSingleResponse, successEnvelope, } from "../schemas.js";
+export function useProductTranslationMutation() {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async ({ productId, input, }) => {
+            const { data } = await fetchWithValidation(`/v1/products/${productId}/translations`, productTranslationSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: async (data) => {
+            await queryClient.invalidateQueries({
+                queryKey: productsQueryKeys.productTranslationsRoot(data.productId),
+            });
+            await queryClient.invalidateQueries({ queryKey: productsQueryKeys.product(data.productId) });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ productId, translationId, input, }) => {
+            const { data } = await fetchWithValidation(`/v1/products/translations/${translationId}`, productTranslationSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return { productId, translation: data };
+        },
+        onSuccess: async ({ productId }) => {
+            await queryClient.invalidateQueries({
+                queryKey: productsQueryKeys.productTranslationsRoot(productId),
+            });
+            await queryClient.invalidateQueries({ queryKey: productsQueryKeys.product(productId) });
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async ({ productId, translationId, }) => {
+            await fetchWithValidation(`/v1/products/translations/${translationId}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" });
+            return { productId };
+        },
+        onSuccess: async ({ productId }) => {
+            await queryClient.invalidateQueries({
+                queryKey: productsQueryKeys.productTranslationsRoot(productId),
+            });
+            await queryClient.invalidateQueries({ queryKey: productsQueryKeys.product(productId) });
+        },
+    });
+    return { create, update, remove };
+}

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

@@ -0,0 +1,28 @@
+export interface UseProductTranslationsOptions {
+    languageTag?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    enabled?: boolean | undefined;
+}
+export declare function useProductTranslations(productId: string | null | undefined, options?: UseProductTranslationsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        productId: string;
+        languageTag: string;
+        slug: string | null;
+        name: string;
+        shortDescription: string | null;
+        description: string | null;
+        inclusionsHtml: string | null;
+        exclusionsHtml: string | null;
+        termsHtml: string | null;
+        seoTitle: string | null;
+        seoDescription: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-product-translations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-translations.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-translations.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,6BAA6B;IAC5C,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAC9B;AAED,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,OAAO,GAAE,6BAAkC;;;;;;;;;;;;;;;;;;;;UAuB5C"}

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

@@ -0,0 +1,24 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { fetchWithValidation, withQueryParams } from "../client.js";
+import { useVoyantProductsContext } from "../provider.js";
+import { productsQueryKeys } from "../query-keys.js";
+import { productTranslationListResponse } from "../schemas.js";
+export function useProductTranslations(productId, options = {}) {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const { enabled = true, ...filters } = options;
+    return useQuery({
+        queryKey: productsQueryKeys.productTranslations(productId ?? "", filters),
+        queryFn: () => {
+            if (!productId)
+                throw new Error("useProductTranslations requires a productId");
+            return fetchWithValidation(withQueryParams("/v1/products/translations", {
+                productId,
+                languageTag: filters.languageTag,
+                limit: filters.limit,
+                offset: filters.offset,
+            }), productTranslationListResponse, { baseUrl, fetcher });
+        },
+        enabled: enabled && Boolean(productId),
+    });
+}

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

@@ -0,0 +1,50 @@
+import { z } from "zod";
+declare const productTypeInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    code: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export type CreateProductTypeInput = z.input<typeof productTypeInputSchema>;
+export type UpdateProductTypeInput = Partial<CreateProductTypeInput>;
+export declare function useProductTypeMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        name: string;
+        code: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        name: string;
+        code: string;
+        description?: string | null | undefined;
+        sortOrder?: number | undefined;
+        active?: boolean | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        name: string;
+        code: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateProductTypeInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+export {};
+//# sourceMappingURL=use-product-type-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-type-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-type-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,sBAAsB;;;;;;;iBAO1B,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC3E,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAA;AAEpE,wBAAgB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBM,MAAM;eAAS,sBAAsB;;;;;EA8BhF"}

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

@@ -0,0 +1,47 @@
+"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 { productTypeSingleResponse, successEnvelope } from "../schemas.js";
+const productTypeInputSchema = z.object({
+    name: z.string().min(1).max(255),
+    code: z.string().min(1).max(100),
+    description: z.string().nullable().optional(),
+    sortOrder: z.number().int().optional(),
+    active: z.boolean().optional(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+});
+export function useProductTypeMutation() {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/products/product-types", productTypeSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.productTypes() });
+            queryClient.setQueryData(productsQueryKeys.productType(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/products/product-types/${id}`, productTypeSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.productTypes() });
+            queryClient.setQueryData(productsQueryKeys.productType(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/products/product-types/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.productTypes() });
+            queryClient.removeQueries({ queryKey: productsQueryKeys.productType(id) });
+        },
+    });
+    return { create, update, remove };
+}

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

@@ -0,0 +1,15 @@
+export interface UseProductTypeOptions {
+    enabled?: boolean;
+}
+export declare function useProductType(id: string | null | undefined, options?: UseProductTypeOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    name: string;
+    code: string;
+    description: string | null;
+    sortOrder: number;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown> | null | undefined;
+}, Error>;
+//# sourceMappingURL=use-product-type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-type.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-type.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,GAAE,qBAA0B;;;;;;;;;;UAQhG"}

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

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

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

@@ -0,0 +1,21 @@
+import type { ProductTypesListFilters } from "../query-keys.js";
+export interface UseProductTypesOptions extends ProductTypesListFilters {
+    enabled?: boolean;
+}
+export declare function useProductTypes(options?: UseProductTypesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        name: string;
+        code: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-product-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-types.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-types.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAA;AAG/D,MAAM,WAAW,sBAAuB,SAAQ,uBAAuB;IACrE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B;;;;;;;;;;;;;;;UAKnE"}

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

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

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

@@ -0,0 +1,16 @@
+export declare function useProductVersionMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        versionNumber: number;
+        snapshot: unknown;
+        authorId: string;
+        notes: string | null;
+        createdAt: string;
+    }, Error, {
+        notes?: string | null | undefined;
+    } & {
+        productId: string;
+    }, unknown>;
+};
+//# sourceMappingURL=use-product-version-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-version-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-version-mutation.ts"],"names":[],"mappings":"AASA,wBAAgB,yBAAyB;;;;;;;;;;;;mBAQO,MAAM;;EAiBrD"}

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

@@ -0,0 +1,22 @@
+"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 { productVersionResponse } from "../schemas.js";
+export function useProductVersionMutation() {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async ({ productId, ...input }) => {
+            const { data } = await fetchWithValidation(`/v1/products/${productId}/versions`, productVersionResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: async (data) => {
+            await queryClient.invalidateQueries({
+                queryKey: productsQueryKeys.productVersions(data.productId),
+            });
+        },
+    });
+    return { create };
+}

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

@@ -0,0 +1,15 @@
+export interface UseProductVersionsOptions {
+    enabled?: boolean;
+}
+export declare function useProductVersions(productId: string | null | undefined, options?: UseProductVersionsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        productId: string;
+        versionNumber: number;
+        snapshot: unknown;
+        authorId: string;
+        notes: string | null;
+        createdAt: string;
+    }[];
+}, Error>;
+//# sourceMappingURL=use-product-versions.d.ts.map

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

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

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

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

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

@@ -0,0 +1,45 @@
+export interface UseProductOptions {
+    enabled?: boolean;
+}
+export declare function useProduct(id: string | undefined, options?: UseProductOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    name: string;
+    status: "draft" | "active" | "archived";
+    description: string | null;
+    inclusionsHtml: string | null;
+    exclusionsHtml: string | null;
+    termsHtml: string | null;
+    termsShowOnContract: boolean;
+    bookingMode: "other" | "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary";
+    capacityMode: "free_sale" | "limited" | "on_request";
+    timezone: string | null;
+    visibility: "public" | "private" | "hidden";
+    activated: boolean;
+    reservationTimeoutMinutes: number | null;
+    sellCurrency: string;
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    marginPercent: number | null;
+    facilityId: string | null;
+    startDate: string | null;
+    endDate: string | null;
+    pax: number | null;
+    productTypeId: string | null;
+    taxClassId: string | null;
+    tags: string[];
+    createdAt: string;
+    updatedAt: string;
+    defaultLanguageTag?: string | null | undefined;
+    contractTemplateId?: string | null | undefined;
+    customerPaymentPolicy?: {
+        deposit: {
+            kind: "none" | "percent" | "fixed_cents";
+            percent?: number | undefined;
+            amountCents?: number | undefined;
+        };
+        minDaysBeforeDepartureForDeposit: number;
+        balanceDueDaysBeforeDeparture: number;
+        balanceDueMinDaysFromNow: number;
+    } | null | undefined;
+}, Error>;
+//# sourceMappingURL=use-product.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-product.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAgBjF"}

package/dist/hooks/use-product.js

@@ -0,0 +1,23 @@
+"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 { productSingleResponse } from "../schemas.js";
+export function useProduct(id, options = {}) {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const { enabled = true } = options;
+    return useQuery({
+        queryKey: productsQueryKeys.product(id ?? ""),
+        queryFn: async () => {
+            if (!id)
+                throw new Error("useProduct requires an id");
+            const { data } = await fetchWithValidation(`/v1/products/${id}`, productSingleResponse, {
+                baseUrl,
+                fetcher,
+            });
+            return data;
+        },
+        enabled: enabled && Boolean(id),
+    });
+}

package/dist/hooks/use-products.d.ts

@@ -0,0 +1,51 @@
+import { type ProductsListFilters } from "../query-keys.js";
+export interface UseProductsOptions extends ProductsListFilters {
+    enabled?: boolean;
+}
+export declare function useProducts(options?: UseProductsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        name: string;
+        status: "draft" | "active" | "archived";
+        description: string | null;
+        inclusionsHtml: string | null;
+        exclusionsHtml: string | null;
+        termsHtml: string | null;
+        termsShowOnContract: boolean;
+        bookingMode: "other" | "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary";
+        capacityMode: "free_sale" | "limited" | "on_request";
+        timezone: string | null;
+        visibility: "public" | "private" | "hidden";
+        activated: boolean;
+        reservationTimeoutMinutes: number | null;
+        sellCurrency: string;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        marginPercent: number | null;
+        facilityId: string | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        productTypeId: string | null;
+        taxClassId: string | null;
+        tags: string[];
+        createdAt: string;
+        updatedAt: string;
+        defaultLanguageTag?: string | null | undefined;
+        contractTemplateId?: string | null | undefined;
+        customerPaymentPolicy?: {
+            deposit: {
+                kind: "none" | "percent" | "fixed_cents";
+                percent?: number | undefined;
+                amountCents?: number | undefined;
+            };
+            minDaysBeforeDepartureForDeposit: number;
+            balanceDueDaysBeforeDeparture: number;
+            balanceDueMinDaysFromNow: number;
+        } | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-products.d.ts.map

package/dist/hooks/use-products.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-products.d.ts","sourceRoot":"","sources":["../../src/hooks/use-products.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,mBAAmB,EAAqB,MAAM,kBAAkB,CAAA;AAG9E,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwB3D"}

package/dist/hooks/use-products.js

@@ -0,0 +1,38 @@
+"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 { productListResponse } from "../schemas.js";
+export function useProducts(options = {}) {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const { enabled = true, ...filters } = options;
+    return useQuery({
+        queryKey: productsQueryKeys.productsList(filters),
+        queryFn: () => {
+            const params = new URLSearchParams();
+            if (filters.status)
+                params.set("status", filters.status);
+            if (filters.bookingMode)
+                params.set("bookingMode", filters.bookingMode);
+            if (filters.visibility)
+                params.set("visibility", filters.visibility);
+            if (filters.activated !== undefined)
+                params.set("activated", String(filters.activated));
+            if (filters.facilityId)
+                params.set("facilityId", filters.facilityId);
+            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${qs ? `?${qs}` : ""}`, productListResponse, {
+                baseUrl,
+                fetcher,
+            });
+        },
+        enabled,
+    });
+}