@voyantjs/pricing-react 0.2.0

package/README.md

@@ -0,0 +1,8 @@
+# @voyantjs/pricing-react
+
+React hooks and provider utilities for Voyant pricing APIs.
+
+Current surface:
+
+- pricing categories
+- pricing category dependencies

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+export type VoyantFetcher = (url: string, init?: RequestInit) => Promise<Response>;
+export declare const defaultFetcher: VoyantFetcher;
+export declare class VoyantApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+export interface FetchWithValidationOptions {
+    baseUrl: string;
+    fetcher: VoyantFetcher;
+}
+export declare function fetchWithValidation<TOut>(path: string, schema: z.ZodType<TOut>, options: FetchWithValidationOptions, init?: RequestInit): Promise<TOut>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;AAElF,eAAO,MAAM,cAAc,EAAE,aACoB,CAAA;AAEjD,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;gBAEV,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;CAM3D;AAaD,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,aAAa,CAAA;CACvB;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAC5C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EACvB,OAAO,EAAE,0BAA0B,EACnC,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/dist/client.js

@@ -0,0 +1,59 @@
+export const defaultFetcher = (url, init) => fetch(url, { credentials: "include", ...init });
+export class VoyantApiError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.name = "VoyantApiError";
+        this.status = status;
+        this.body = body;
+    }
+}
+function extractErrorMessage(status, statusText, body) {
+    if (typeof body === "object" && body !== null && "error" in body) {
+        const err = body.error;
+        if (typeof err === "string")
+            return err;
+        if (typeof err === "object" && err !== null && "message" in err) {
+            return String(err.message);
+        }
+    }
+    return `Voyant API error: ${status} ${statusText}`;
+}
+export async function fetchWithValidation(path, schema, options, init) {
+    const url = joinUrl(options.baseUrl, path);
+    const headers = new Headers(init?.headers);
+    if (init?.body !== undefined && !headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+    }
+    const response = await options.fetcher(url, { ...init, headers });
+    if (!response.ok) {
+        const body = await safeJson(response);
+        throw new VoyantApiError(extractErrorMessage(response.status, response.statusText, body), response.status, body);
+    }
+    if (response.status === 204) {
+        return schema.parse(undefined);
+    }
+    const body = await safeJson(response);
+    const parsed = schema.safeParse(body);
+    if (!parsed.success) {
+        throw new VoyantApiError(`Voyant API response failed validation: ${parsed.error.message}`, response.status, body);
+    }
+    return parsed.data;
+}
+async function safeJson(response) {
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function joinUrl(baseUrl, path) {
+    const trimmedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const trimmedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${trimmedBase}${trimmedPath}`;
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./use-pricing-categories.js";
+export * from "./use-pricing-category.js";
+export * from "./use-pricing-category-dependencies.js";
+export * from "./use-pricing-category-dependency.js";
+export * from "./use-pricing-category-dependency-mutation.js";
+export * from "./use-pricing-category-mutation.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA;AAC3C,cAAc,2BAA2B,CAAA;AACzC,cAAc,wCAAwC,CAAA;AACtD,cAAc,sCAAsC,CAAA;AACpD,cAAc,+CAA+C,CAAA;AAC7D,cAAc,oCAAoC,CAAA"}

package/dist/hooks/index.js

@@ -0,0 +1,6 @@
+export * from "./use-pricing-categories.js";
+export * from "./use-pricing-category.js";
+export * from "./use-pricing-category-dependencies.js";
+export * from "./use-pricing-category-dependency.js";
+export * from "./use-pricing-category-dependency-mutation.js";
+export * from "./use-pricing-category-mutation.js";

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

@@ -0,0 +1,30 @@
+import { type PricingCategoriesListFilters } from "../query-keys.js";
+export interface UsePricingCategoriesOptions extends PricingCategoriesListFilters {
+    enabled?: boolean;
+}
+export declare function usePricingCategories(options?: UsePricingCategoriesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        productId: string | null;
+        optionId: string | null;
+        unitId: string | null;
+        code: string | null;
+        name: string;
+        categoryType: "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle" | "service" | "other";
+        seatOccupancy: number;
+        groupSize: number | null;
+        isAgeQualified: boolean;
+        minAge: number | null;
+        maxAge: number | null;
+        internalUseOnly: boolean;
+        active: boolean;
+        sortOrder: number;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-pricing-categories.d.ts.map

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

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

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

@@ -0,0 +1,33 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantPricingContext } from "../provider.js";
+import { pricingQueryKeys } from "../query-keys.js";
+import { pricingCategoryListResponse } from "../schemas.js";
+export function usePricingCategories(options = {}) {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const { enabled = true, ...filters } = options;
+    return useQuery({
+        queryKey: pricingQueryKeys.pricingCategoriesList(filters),
+        queryFn: () => {
+            const params = new URLSearchParams();
+            if (filters.productId)
+                params.set("productId", filters.productId);
+            if (filters.optionId)
+                params.set("optionId", filters.optionId);
+            if (filters.unitId)
+                params.set("unitId", filters.unitId);
+            if (filters.categoryType)
+                params.set("categoryType", filters.categoryType);
+            if (filters.active !== undefined)
+                params.set("active", String(filters.active));
+            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/pricing/pricing-categories${qs ? `?${qs}` : ""}`, pricingCategoryListResponse, { baseUrl, fetcher });
+        },
+        enabled,
+    });
+}

package/dist/hooks/use-pricing-category-dependencies.d.ts

@@ -0,0 +1,22 @@
+import { type PricingCategoryDependenciesListFilters } from "../query-keys.js";
+export interface UsePricingCategoryDependenciesOptions extends PricingCategoryDependenciesListFilters {
+    enabled?: boolean;
+}
+export declare function usePricingCategoryDependencies(options?: UsePricingCategoryDependenciesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        pricingCategoryId: string;
+        masterPricingCategoryId: string;
+        dependencyType: "requires" | "limits_per_master" | "limits_sum" | "excludes";
+        maxPerMaster: number | null;
+        maxDependentSum: number | null;
+        active: boolean;
+        notes: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-pricing-category-dependencies.d.ts.map

package/dist/hooks/use-pricing-category-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pricing-category-dependencies.d.ts","sourceRoot":"","sources":["../../src/hooks/use-pricing-category-dependencies.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,sCAAsC,EAAoB,MAAM,kBAAkB,CAAA;AAGhG,MAAM,WAAW,qCACf,SAAQ,sCAAsC;IAC9C,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,GAAE,qCAA0C;;;;;;;;;;;;;;;;UA0BpD"}

package/dist/hooks/use-pricing-category-dependencies.js

@@ -0,0 +1,32 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantPricingContext } from "../provider.js";
+import { pricingQueryKeys } from "../query-keys.js";
+import { pricingCategoryDependencyListResponse } from "../schemas.js";
+export function usePricingCategoryDependencies(options = {}) {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const { enabled = true, ...filters } = options;
+    return useQuery({
+        queryKey: pricingQueryKeys.pricingCategoryDependenciesList(filters),
+        queryFn: () => {
+            const params = new URLSearchParams();
+            if (filters.pricingCategoryId)
+                params.set("pricingCategoryId", filters.pricingCategoryId);
+            if (filters.masterPricingCategoryId) {
+                params.set("masterPricingCategoryId", filters.masterPricingCategoryId);
+            }
+            if (filters.dependencyType)
+                params.set("dependencyType", filters.dependencyType);
+            if (filters.active !== undefined)
+                params.set("active", String(filters.active));
+            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/pricing/pricing-category-dependencies${qs ? `?${qs}` : ""}`, pricingCategoryDependencyListResponse, { baseUrl, fetcher });
+        },
+        enabled,
+    });
+}

package/dist/hooks/use-pricing-category-dependency-mutation.d.ts

@@ -0,0 +1,43 @@
+export interface CreatePricingCategoryDependencyInput {
+    pricingCategoryId: string;
+    masterPricingCategoryId: string;
+    dependencyType?: "requires" | "limits_per_master" | "limits_sum" | "excludes";
+    maxPerMaster?: number | null;
+    maxDependentSum?: number | null;
+    active?: boolean;
+    notes?: string | null;
+}
+export type UpdatePricingCategoryDependencyInput = Partial<CreatePricingCategoryDependencyInput>;
+export declare function usePricingCategoryDependencyMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        pricingCategoryId: string;
+        masterPricingCategoryId: string;
+        dependencyType: "requires" | "limits_per_master" | "limits_sum" | "excludes";
+        maxPerMaster: number | null;
+        maxDependentSum: number | null;
+        active: boolean;
+        notes: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, CreatePricingCategoryDependencyInput, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        pricingCategoryId: string;
+        masterPricingCategoryId: string;
+        dependencyType: "requires" | "limits_per_master" | "limits_sum" | "excludes";
+        maxPerMaster: number | null;
+        maxDependentSum: number | null;
+        active: boolean;
+        notes: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        id: string;
+        input: UpdatePricingCategoryDependencyInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-pricing-category-dependency-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-pricing-category-dependency-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-pricing-category-dependency-mutation.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,oCAAoC;IACnD,iBAAiB,EAAE,MAAM,CAAA;IACzB,uBAAuB,EAAE,MAAM,CAAA;IAC/B,cAAc,CAAC,EAAE,UAAU,GAAG,mBAAmB,GAAG,YAAY,GAAG,UAAU,CAAA;IAC7E,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED,MAAM,MAAM,oCAAoC,GAAG,OAAO,CAAC,oCAAoC,CAAC,CAAA;AAEhG,wBAAgB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;YA0B1C,MAAM;eACH,oCAAoC;;;;;EAmChD"}

package/dist/hooks/use-pricing-category-dependency-mutation.js

@@ -0,0 +1,43 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantPricingContext } from "../provider.js";
+import { pricingQueryKeys } from "../query-keys.js";
+import { pricingCategoryDependencySingleResponse, successEnvelope } from "../schemas.js";
+export function usePricingCategoryDependencyMutation() {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/pricing/pricing-category-dependencies", pricingCategoryDependencySingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: () => {
+            void queryClient.invalidateQueries({
+                queryKey: pricingQueryKeys.pricingCategoryDependencies(),
+            });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input, }) => {
+            const { data } = await fetchWithValidation(`/v1/pricing/pricing-category-dependencies/${id}`, pricingCategoryDependencySingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({
+                queryKey: pricingQueryKeys.pricingCategoryDependencies(),
+            });
+            queryClient.setQueryData(pricingQueryKeys.pricingCategoryDependency(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/pricing/pricing-category-dependencies/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({
+                queryKey: pricingQueryKeys.pricingCategoryDependencies(),
+            });
+            queryClient.removeQueries({ queryKey: pricingQueryKeys.pricingCategoryDependency(id) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-pricing-category-dependency.d.ts

@@ -0,0 +1,16 @@
+export interface UsePricingCategoryDependencyOptions {
+    enabled?: boolean;
+}
+export declare function usePricingCategoryDependency(id: string | null | undefined, options?: UsePricingCategoryDependencyOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    pricingCategoryId: string;
+    masterPricingCategoryId: string;
+    dependencyType: "requires" | "limits_per_master" | "limits_sum" | "excludes";
+    maxPerMaster: number | null;
+    maxDependentSum: number | null;
+    active: boolean;
+    notes: string | null;
+    createdAt: string;
+    updatedAt: string;
+}, Error>;
+//# sourceMappingURL=use-pricing-category-dependency.d.ts.map

package/dist/hooks/use-pricing-category-dependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pricing-category-dependency.d.ts","sourceRoot":"","sources":["../../src/hooks/use-pricing-category-dependency.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,mCAAmC;IAClD,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,4BAA4B,CAC1C,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7B,OAAO,GAAE,mCAAwC;;;;;;;;;;;UAiBlD"}

package/dist/hooks/use-pricing-category-dependency.js

@@ -0,0 +1,18 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantPricingContext } from "../provider.js";
+import { pricingQueryKeys } from "../query-keys.js";
+import { pricingCategoryDependencySingleResponse } from "../schemas.js";
+export function usePricingCategoryDependency(id, options = {}) {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const { enabled = true } = options;
+    return useQuery({
+        queryKey: pricingQueryKeys.pricingCategoryDependency(id ?? "__missing__"),
+        queryFn: async () => {
+            const { data } = await fetchWithValidation(`/v1/pricing/pricing-category-dependencies/${id}`, pricingCategoryDependencySingleResponse, { baseUrl, fetcher });
+            return data;
+        },
+        enabled: enabled && Boolean(id),
+    });
+}

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

@@ -0,0 +1,67 @@
+export interface CreatePricingCategoryInput {
+    productId?: string | null;
+    optionId?: string | null;
+    unitId?: string | null;
+    code?: string | null;
+    name: string;
+    categoryType?: "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle" | "service" | "other";
+    seatOccupancy?: number;
+    groupSize?: number | null;
+    isAgeQualified?: boolean;
+    minAge?: number | null;
+    maxAge?: number | null;
+    internalUseOnly?: boolean;
+    active?: boolean;
+    sortOrder?: number;
+    metadata?: Record<string, unknown> | null;
+}
+export type UpdatePricingCategoryInput = Partial<CreatePricingCategoryInput>;
+export declare function usePricingCategoryMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string | null;
+        optionId: string | null;
+        unitId: string | null;
+        code: string | null;
+        name: string;
+        categoryType: "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle" | "service" | "other";
+        seatOccupancy: number;
+        groupSize: number | null;
+        isAgeQualified: boolean;
+        minAge: number | null;
+        maxAge: number | null;
+        internalUseOnly: boolean;
+        active: boolean;
+        sortOrder: number;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, CreatePricingCategoryInput, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string | null;
+        optionId: string | null;
+        unitId: string | null;
+        code: string | null;
+        name: string;
+        categoryType: "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle" | "service" | "other";
+        seatOccupancy: number;
+        groupSize: number | null;
+        isAgeQualified: boolean;
+        minAge: number | null;
+        maxAge: number | null;
+        internalUseOnly: boolean;
+        active: boolean;
+        sortOrder: number;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdatePricingCategoryInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-pricing-category-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-pricing-category-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-pricing-category-mutation.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,0BAA0B;IACzC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EACT,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,MAAM,GACN,SAAS,GACT,SAAS,GACT,OAAO,CAAA;IACX,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;CAC1C;AAED,MAAM,MAAM,0BAA0B,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAA;AAE5E,wBAAgB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAoBE,MAAM;eAAS,0BAA0B;;;;;EA8BpF"}

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

@@ -0,0 +1,37 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantPricingContext } from "../provider.js";
+import { pricingQueryKeys } from "../query-keys.js";
+import { pricingCategorySingleResponse, successEnvelope } from "../schemas.js";
+export function usePricingCategoryMutation() {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/pricing/pricing-categories", pricingCategorySingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.pricingCategories() });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/pricing/pricing-categories/${id}`, pricingCategorySingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.pricingCategories() });
+            queryClient.setQueryData(pricingQueryKeys.pricingCategory(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/pricing/pricing-categories/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.pricingCategories() });
+            queryClient.removeQueries({ queryKey: pricingQueryKeys.pricingCategory(id) });
+        },
+    });
+    return { create, update, remove };
+}

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

@@ -0,0 +1,24 @@
+export interface UsePricingCategoryOptions {
+    enabled?: boolean;
+}
+export declare function usePricingCategory(id: string | null | undefined, options?: UsePricingCategoryOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    productId: string | null;
+    optionId: string | null;
+    unitId: string | null;
+    code: string | null;
+    name: string;
+    categoryType: "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle" | "service" | "other";
+    seatOccupancy: number;
+    groupSize: number | null;
+    isAgeQualified: boolean;
+    minAge: number | null;
+    maxAge: number | null;
+    internalUseOnly: boolean;
+    active: boolean;
+    sortOrder: number;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown> | null | undefined;
+}, Error>;
+//# sourceMappingURL=use-pricing-category.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-pricing-category.d.ts","sourceRoot":"","sources":["../../src/hooks/use-pricing-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-pricing-category.js

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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { defaultFetcher, fetchWithValidation, VoyantApiError, type VoyantFetcher, } from "./client.js";
+export * from "./hooks/index.js";
+export { useVoyantPricingContext, type VoyantPricingContextValue, VoyantPricingProvider, type VoyantPricingProviderProps, } from "./provider.js";
+export { pricingQueryKeys } from "./query-keys.js";
+export * from "./schemas.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,KAAK,aAAa,GACnB,MAAM,aAAa,CAAA;AACpB,cAAc,kBAAkB,CAAA;AAChC,OAAO,EACL,uBAAuB,EACvB,KAAK,yBAAyB,EAC9B,qBAAqB,EACrB,KAAK,0BAA0B,GAChC,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAClD,cAAc,cAAc,CAAA"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { defaultFetcher, fetchWithValidation, VoyantApiError, } from "./client.js";
+export * from "./hooks/index.js";
+export { useVoyantPricingContext, VoyantPricingProvider, } from "./provider.js";
+export { pricingQueryKeys } from "./query-keys.js";
+export * from "./schemas.js";

package/dist/provider.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+import { type VoyantFetcher } from "./client.js";
+export interface VoyantPricingContextValue {
+    baseUrl: string;
+    fetcher: VoyantFetcher;
+}
+export interface VoyantPricingProviderProps {
+    baseUrl: string;
+    fetcher?: VoyantFetcher;
+    children: ReactNode;
+}
+export declare function VoyantPricingProvider({ baseUrl, fetcher, children }: VoyantPricingProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useVoyantPricingContext(): VoyantPricingContextValue;
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,SAAS,EAAuB,MAAM,OAAO,CAAA;AAE1E,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhE,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,aAAa,CAAA;CACvB;AAID,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,QAAQ,EAAE,SAAS,CAAA;CACpB;AAED,wBAAgB,qBAAqB,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,0BAA0B,2CAO/F;AAED,wBAAgB,uBAAuB,IAAI,yBAAyB,CAQnE"}

package/dist/provider.js

@@ -0,0 +1,16 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from "react";
+import { defaultFetcher } from "./client.js";
+const VoyantPricingContext = createContext(null);
+export function VoyantPricingProvider({ baseUrl, fetcher, children }) {
+    const value = useMemo(() => ({ baseUrl, fetcher: fetcher ?? defaultFetcher }), [baseUrl, fetcher]);
+    return _jsx(VoyantPricingContext.Provider, { value: value, children: children });
+}
+export function useVoyantPricingContext() {
+    const context = useContext(VoyantPricingContext);
+    if (!context) {
+        throw new Error('useVoyantPricingContext must be used inside <VoyantPricingProvider>. Wrap your app with <VoyantPricingProvider baseUrl="/api" />.');
+    }
+    return context;
+}

package/dist/query-keys.d.ts

@@ -0,0 +1,27 @@
+export interface PricingCategoriesListFilters {
+    productId?: string | undefined;
+    optionId?: string | undefined;
+    unitId?: string | undefined;
+    categoryType?: string | undefined;
+    active?: boolean | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}
+export interface PricingCategoryDependenciesListFilters {
+    pricingCategoryId?: string | undefined;
+    masterPricingCategoryId?: string | undefined;
+    dependencyType?: string | undefined;
+    active?: boolean | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}
+export declare const pricingQueryKeys: {
+    readonly all: readonly ["voyant", "pricing"];
+    readonly pricingCategories: () => readonly ["voyant", "pricing", "pricing-categories"];
+    readonly pricingCategoriesList: (filters: PricingCategoriesListFilters) => readonly ["voyant", "pricing", "pricing-categories", "list", PricingCategoriesListFilters];
+    readonly pricingCategory: (id: string) => readonly ["voyant", "pricing", "pricing-categories", "detail", string];
+    readonly pricingCategoryDependencies: () => readonly ["voyant", "pricing", "pricing-category-dependencies"];
+    readonly pricingCategoryDependenciesList: (filters: PricingCategoryDependenciesListFilters) => readonly ["voyant", "pricing", "pricing-category-dependencies", "list", PricingCategoryDependenciesListFilters];
+    readonly pricingCategoryDependency: (id: string) => readonly ["voyant", "pricing", "pricing-category-dependencies", "detail", string];
+};
+//# sourceMappingURL=query-keys.d.ts.map

package/dist/query-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-keys.d.ts","sourceRoot":"","sources":["../src/query-keys.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,4BAA4B;IAC3C,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC5B;AAED,MAAM,WAAW,sCAAsC;IACrD,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,uBAAuB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5C,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC5B;AAED,eAAO,MAAM,gBAAgB;;;8CAIM,4BAA4B;mCAEvC,MAAM;;wDAIe,sCAAsC;6CAEjD,MAAM;CAE9B,CAAA"}

package/dist/query-keys.js

@@ -0,0 +1,9 @@
+export const pricingQueryKeys = {
+    all: ["voyant", "pricing"],
+    pricingCategories: () => [...pricingQueryKeys.all, "pricing-categories"],
+    pricingCategoriesList: (filters) => [...pricingQueryKeys.pricingCategories(), "list", filters],
+    pricingCategory: (id) => [...pricingQueryKeys.pricingCategories(), "detail", id],
+    pricingCategoryDependencies: () => [...pricingQueryKeys.all, "pricing-category-dependencies"],
+    pricingCategoryDependenciesList: (filters) => [...pricingQueryKeys.pricingCategoryDependencies(), "list", filters],
+    pricingCategoryDependency: (id) => [...pricingQueryKeys.pricingCategoryDependencies(), "detail", id],
+};

package/dist/schemas.d.ts

@@ -0,0 +1,171 @@
+import { z } from "zod";
+export declare const paginatedEnvelope: <T extends z.ZodTypeAny>(item: T) => z.ZodObject<{
+    data: z.ZodArray<T>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export declare const singleEnvelope: <T extends z.ZodTypeAny>(item: T) => z.ZodObject<{
+    data: T;
+}, z.core.$strip>;
+export declare const successEnvelope: z.ZodObject<{
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const pricingCategoryRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    productId: z.ZodNullable<z.ZodString>;
+    optionId: z.ZodNullable<z.ZodString>;
+    unitId: z.ZodNullable<z.ZodString>;
+    code: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    categoryType: z.ZodEnum<{
+        adult: "adult";
+        child: "child";
+        infant: "infant";
+        senior: "senior";
+        group: "group";
+        room: "room";
+        vehicle: "vehicle";
+        service: "service";
+        other: "other";
+    }>;
+    seatOccupancy: z.ZodNumber;
+    groupSize: z.ZodNullable<z.ZodNumber>;
+    isAgeQualified: z.ZodBoolean;
+    minAge: z.ZodNullable<z.ZodNumber>;
+    maxAge: z.ZodNullable<z.ZodNumber>;
+    internalUseOnly: z.ZodBoolean;
+    active: z.ZodBoolean;
+    sortOrder: z.ZodNumber;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type PricingCategoryRecord = z.infer<typeof pricingCategoryRecordSchema>;
+export declare const pricingCategoryDependencyRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    pricingCategoryId: z.ZodString;
+    masterPricingCategoryId: z.ZodString;
+    dependencyType: z.ZodEnum<{
+        requires: "requires";
+        limits_per_master: "limits_per_master";
+        limits_sum: "limits_sum";
+        excludes: "excludes";
+    }>;
+    maxPerMaster: z.ZodNullable<z.ZodNumber>;
+    maxDependentSum: z.ZodNullable<z.ZodNumber>;
+    active: z.ZodBoolean;
+    notes: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type PricingCategoryDependencyRecord = z.infer<typeof pricingCategoryDependencyRecordSchema>;
+export declare const pricingCategoryListResponse: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        productId: z.ZodNullable<z.ZodString>;
+        optionId: z.ZodNullable<z.ZodString>;
+        unitId: z.ZodNullable<z.ZodString>;
+        code: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        categoryType: z.ZodEnum<{
+            adult: "adult";
+            child: "child";
+            infant: "infant";
+            senior: "senior";
+            group: "group";
+            room: "room";
+            vehicle: "vehicle";
+            service: "service";
+            other: "other";
+        }>;
+        seatOccupancy: z.ZodNumber;
+        groupSize: z.ZodNullable<z.ZodNumber>;
+        isAgeQualified: z.ZodBoolean;
+        minAge: z.ZodNullable<z.ZodNumber>;
+        maxAge: z.ZodNullable<z.ZodNumber>;
+        internalUseOnly: z.ZodBoolean;
+        active: z.ZodBoolean;
+        sortOrder: z.ZodNumber;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export declare const pricingCategorySingleResponse: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        productId: z.ZodNullable<z.ZodString>;
+        optionId: z.ZodNullable<z.ZodString>;
+        unitId: z.ZodNullable<z.ZodString>;
+        code: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        categoryType: z.ZodEnum<{
+            adult: "adult";
+            child: "child";
+            infant: "infant";
+            senior: "senior";
+            group: "group";
+            room: "room";
+            vehicle: "vehicle";
+            service: "service";
+            other: "other";
+        }>;
+        seatOccupancy: z.ZodNumber;
+        groupSize: z.ZodNullable<z.ZodNumber>;
+        isAgeQualified: z.ZodBoolean;
+        minAge: z.ZodNullable<z.ZodNumber>;
+        maxAge: z.ZodNullable<z.ZodNumber>;
+        internalUseOnly: z.ZodBoolean;
+        active: z.ZodBoolean;
+        sortOrder: z.ZodNumber;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const pricingCategoryDependencyListResponse: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        pricingCategoryId: z.ZodString;
+        masterPricingCategoryId: z.ZodString;
+        dependencyType: z.ZodEnum<{
+            requires: "requires";
+            limits_per_master: "limits_per_master";
+            limits_sum: "limits_sum";
+            excludes: "excludes";
+        }>;
+        maxPerMaster: z.ZodNullable<z.ZodNumber>;
+        maxDependentSum: z.ZodNullable<z.ZodNumber>;
+        active: z.ZodBoolean;
+        notes: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export declare const pricingCategoryDependencySingleResponse: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        pricingCategoryId: z.ZodString;
+        masterPricingCategoryId: z.ZodString;
+        dependencyType: z.ZodEnum<{
+            requires: "requires";
+            limits_per_master: "limits_per_master";
+            limits_sum: "limits_sum";
+            excludes: "excludes";
+        }>;
+        maxPerMaster: z.ZodNullable<z.ZodNumber>;
+        maxDependentSum: z.ZodNullable<z.ZodNumber>;
+        active: z.ZodBoolean;
+        notes: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC;;;;;iBAM7D,CAAA;AAEJ,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC;;iBAA6B,CAAA;AAE3F,eAAO,MAAM,eAAe;;iBAAqC,CAAA;AAEjE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BtC,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE/E,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;iBAWhD,CAAA;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA;AAEnG,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAiD,CAAA;AACzF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA8C,CAAA;AACxF,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;iBAEjD,CAAA;AACD,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;iBAEnD,CAAA"}

package/dist/schemas.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+export const paginatedEnvelope = (item) => z.object({
+    data: z.array(item),
+    total: z.number().int(),
+    limit: z.number().int(),
+    offset: z.number().int(),
+});
+export const singleEnvelope = (item) => z.object({ data: item });
+export const successEnvelope = z.object({ success: z.boolean() });
+export const pricingCategoryRecordSchema = z.object({
+    id: z.string(),
+    productId: z.string().nullable(),
+    optionId: z.string().nullable(),
+    unitId: z.string().nullable(),
+    code: z.string().nullable(),
+    name: z.string(),
+    categoryType: z.enum([
+        "adult",
+        "child",
+        "infant",
+        "senior",
+        "group",
+        "room",
+        "vehicle",
+        "service",
+        "other",
+    ]),
+    seatOccupancy: z.number().int(),
+    groupSize: z.number().int().nullable(),
+    isAgeQualified: z.boolean(),
+    minAge: z.number().int().nullable(),
+    maxAge: z.number().int().nullable(),
+    internalUseOnly: z.boolean(),
+    active: z.boolean(),
+    sortOrder: z.number().int(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const pricingCategoryDependencyRecordSchema = z.object({
+    id: z.string(),
+    pricingCategoryId: z.string(),
+    masterPricingCategoryId: z.string(),
+    dependencyType: z.enum(["requires", "limits_per_master", "limits_sum", "excludes"]),
+    maxPerMaster: z.number().int().nullable(),
+    maxDependentSum: z.number().int().nullable(),
+    active: z.boolean(),
+    notes: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const pricingCategoryListResponse = paginatedEnvelope(pricingCategoryRecordSchema);
+export const pricingCategorySingleResponse = singleEnvelope(pricingCategoryRecordSchema);
+export const pricingCategoryDependencyListResponse = paginatedEnvelope(pricingCategoryDependencyRecordSchema);
+export const pricingCategoryDependencySingleResponse = singleEnvelope(pricingCategoryDependencyRecordSchema);

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@voyantjs/pricing-react",
+  "version": "0.2.0",
+  "license": "FSL-1.1-Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/voyantjs/voyant.git",
+    "directory": "packages/pricing-react"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./provider": "./src/provider.tsx",
+    "./hooks": "./src/hooks/index.ts",
+    "./client": "./src/client.ts",
+    "./query-keys": "./src/query-keys.ts"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "prepack": "pnpm run build",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run --passWithNoTests"
+  },
+  "peerDependencies": {
+    "@voyantjs/pricing": "workspace:*",
+    "@tanstack/react-query": "^5.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@tanstack/react-query": "^5.96.2",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@voyantjs/pricing": "workspace:*",
+    "@voyantjs/voyant-typescript-config": "workspace:*",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2",
+    "zod": "^4.3.6"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      },
+      "./provider": {
+        "types": "./dist/provider.d.ts",
+        "import": "./dist/provider.js"
+      },
+      "./hooks": {
+        "types": "./dist/hooks/index.d.ts",
+        "import": "./dist/hooks/index.js"
+      },
+      "./client": {
+        "types": "./dist/client.d.ts",
+        "import": "./dist/client.js"
+      },
+      "./query-keys": {
+        "types": "./dist/query-keys.d.ts",
+        "import": "./dist/query-keys.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  }
+}