@voyantjs/pricing-react 0.2.0 → 0.3.1

package/dist/hooks/use-option-start-time-rule-mutation.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+declare const optionStartTimeRuleInputSchema: z.ZodObject<{
+    optionPriceRuleId: z.ZodString;
+    optionId: z.ZodString;
+    startTimeId: z.ZodString;
+    ruleMode: z.ZodEnum<{
+        override: "override";
+        included: "included";
+        excluded: "excluded";
+        adjustment: "adjustment";
+    }>;
+    adjustmentType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        fixed: "fixed";
+        percentage: "percentage";
+    }>>>;
+    sellAdjustmentCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    costAdjustmentCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    adjustmentBasisPoints: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type CreateOptionStartTimeRuleInput = z.input<typeof optionStartTimeRuleInputSchema>;
+export type UpdateOptionStartTimeRuleInput = Partial<CreateOptionStartTimeRuleInput>;
+export declare function useOptionStartTimeRuleMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        startTimeId: string;
+        ruleMode: "override" | "included" | "excluded" | "adjustment";
+        adjustmentType: "fixed" | "percentage" | null;
+        sellAdjustmentCents: number | null;
+        costAdjustmentCents: number | null;
+        adjustmentBasisPoints: number | null;
+        active: boolean;
+        notes: string | null;
+    }, Error, {
+        optionPriceRuleId: string;
+        optionId: string;
+        startTimeId: string;
+        ruleMode: "override" | "included" | "excluded" | "adjustment";
+        adjustmentType?: "fixed" | "percentage" | null | undefined;
+        sellAdjustmentCents?: number | null | undefined;
+        costAdjustmentCents?: number | null | undefined;
+        adjustmentBasisPoints?: number | null | undefined;
+        active?: boolean | undefined;
+        notes?: string | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        startTimeId: string;
+        ruleMode: "override" | "included" | "excluded" | "adjustment";
+        adjustmentType: "fixed" | "percentage" | null;
+        sellAdjustmentCents: number | null;
+        costAdjustmentCents: number | null;
+        adjustmentBasisPoints: number | null;
+        active: boolean;
+        notes: string | null;
+    }, Error, {
+        id: string;
+        input: UpdateOptionStartTimeRuleInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+export {};
+//# sourceMappingURL=use-option-start-time-rule-mutation.d.ts.map

package/dist/hooks/use-option-start-time-rule-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-start-time-rule-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-start-time-rule-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;iBAWlC,CAAA;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC3F,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAAA;AAEpF,wBAAgB,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBF,MAAM;eAAS,8BAA8B;;;;;EA8BxF"}

package/dist/hooks/use-option-start-time-rule-mutation.js

@@ -0,0 +1,51 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { z } from "zod";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantPricingContext } from "../provider.js";
+import { pricingQueryKeys } from "../query-keys.js";
+import { optionStartTimeRuleSingleResponse, successEnvelope } from "../schemas.js";
+const optionStartTimeRuleInputSchema = z.object({
+    optionPriceRuleId: z.string(),
+    optionId: z.string(),
+    startTimeId: z.string(),
+    ruleMode: z.enum(["included", "excluded", "override", "adjustment"]),
+    adjustmentType: z.enum(["fixed", "percentage"]).nullable().optional(),
+    sellAdjustmentCents: z.number().int().min(0).nullable().optional(),
+    costAdjustmentCents: z.number().int().min(0).nullable().optional(),
+    adjustmentBasisPoints: z.number().int().min(0).max(10000).nullable().optional(),
+    active: z.boolean().optional(),
+    notes: z.string().nullable().optional(),
+});
+export function useOptionStartTimeRuleMutation() {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/pricing/option-start-time-rules", optionStartTimeRuleSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionStartTimeRules() });
+            queryClient.setQueryData(pricingQueryKeys.optionStartTimeRule(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/pricing/option-start-time-rules/${id}`, optionStartTimeRuleSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionStartTimeRules() });
+            queryClient.setQueryData(pricingQueryKeys.optionStartTimeRule(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/pricing/option-start-time-rules/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionStartTimeRules() });
+            queryClient.removeQueries({ queryKey: pricingQueryKeys.optionStartTimeRule(id) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-option-start-time-rule.d.ts

@@ -0,0 +1,17 @@
+export interface UseOptionStartTimeRuleOptions {
+    enabled?: boolean;
+}
+export declare function useOptionStartTimeRule(id: string | null | undefined, options?: UseOptionStartTimeRuleOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    optionPriceRuleId: string;
+    optionId: string;
+    startTimeId: string;
+    ruleMode: "override" | "included" | "excluded" | "adjustment";
+    adjustmentType: "fixed" | "percentage" | null;
+    sellAdjustmentCents: number | null;
+    costAdjustmentCents: number | null;
+    adjustmentBasisPoints: number | null;
+    active: boolean;
+    notes: string | null;
+}, Error>;
+//# sourceMappingURL=use-option-start-time-rule.d.ts.map

package/dist/hooks/use-option-start-time-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-start-time-rule.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-start-time-rule.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,6BAA6B;IAC5C,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7B,OAAO,GAAE,6BAAkC;;;;;;;;;;;;UAS5C"}

package/dist/hooks/use-option-start-time-rule.js

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantPricingContext } from "../provider.js";
+import { getOptionStartTimeRuleQueryOptions } from "../query-options.js";
+export function useOptionStartTimeRule(id, options = {}) {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getOptionStartTimeRuleQueryOptions({ baseUrl, fetcher }, id ?? "__missing__"),
+        enabled: enabled && Boolean(id),
+    });
+}

package/dist/hooks/use-option-start-time-rules.d.ts

@@ -0,0 +1,23 @@
+import type { OptionStartTimeRulesListFilters } from "../query-keys.js";
+export interface UseOptionStartTimeRulesOptions extends OptionStartTimeRulesListFilters {
+    enabled?: boolean;
+}
+export declare function useOptionStartTimeRules(options?: UseOptionStartTimeRulesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        startTimeId: string;
+        ruleMode: "override" | "included" | "excluded" | "adjustment";
+        adjustmentType: "fixed" | "percentage" | null;
+        sellAdjustmentCents: number | null;
+        costAdjustmentCents: number | null;
+        adjustmentBasisPoints: number | null;
+        active: boolean;
+        notes: string | null;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-option-start-time-rules.d.ts.map

package/dist/hooks/use-option-start-time-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-start-time-rules.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-start-time-rules.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,kBAAkB,CAAA;AAGvE,MAAM,WAAW,8BAA+B,SAAQ,+BAA+B;IACrF,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,8BAAmC;;;;;;;;;;;;;;;;;UAQnF"}

package/dist/hooks/use-option-start-time-rules.js

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

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

@@ -0,0 +1,79 @@
+import { z } from "zod";
+declare const optionUnitPriceRuleInputSchema: z.ZodObject<{
+    optionPriceRuleId: z.ZodString;
+    optionId: z.ZodString;
+    unitId: z.ZodString;
+    pricingCategoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pricingMode: z.ZodEnum<{
+        included: "included";
+        per_person: "per_person";
+        per_booking: "per_booking";
+        on_request: "on_request";
+        free: "free";
+        per_unit: "per_unit";
+    }>;
+    sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    minQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export type CreateOptionUnitPriceRuleInput = z.input<typeof optionUnitPriceRuleInputSchema>;
+export type UpdateOptionUnitPriceRuleInput = Partial<CreateOptionUnitPriceRuleInput>;
+export declare function useOptionUnitPriceRuleMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        unitId: string;
+        pricingCategoryId: string | null;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "free" | "per_unit";
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        sortOrder: number;
+        active: boolean;
+        notes: string | null;
+    }, Error, {
+        optionPriceRuleId: string;
+        optionId: string;
+        unitId: string;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "free" | "per_unit";
+        pricingCategoryId?: string | null | undefined;
+        sellAmountCents?: number | null | undefined;
+        costAmountCents?: number | null | undefined;
+        minQuantity?: number | null | undefined;
+        maxQuantity?: number | null | undefined;
+        active?: boolean | undefined;
+        sortOrder?: number | undefined;
+        notes?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        unitId: string;
+        pricingCategoryId: string | null;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "free" | "per_unit";
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        sortOrder: number;
+        active: boolean;
+        notes: string | null;
+    }, Error, {
+        id: string;
+        input: UpdateOptionUnitPriceRuleInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+export {};
+//# sourceMappingURL=use-option-unit-price-rule-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-unit-price-rule-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-unit-price-rule-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;iBAclC,CAAA;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC3F,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAAA;AAEpF,wBAAgB,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBF,MAAM;eAAS,8BAA8B;;;;;EA8BxF"}

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

@@ -0,0 +1,54 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { z } from "zod";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantPricingContext } from "../provider.js";
+import { pricingQueryKeys } from "../query-keys.js";
+import { optionUnitPriceRuleSingleResponse, successEnvelope } from "../schemas.js";
+const optionUnitPriceRuleInputSchema = z.object({
+    optionPriceRuleId: z.string(),
+    optionId: z.string(),
+    unitId: z.string(),
+    pricingCategoryId: z.string().nullable().optional(),
+    pricingMode: z.enum(["per_unit", "per_person", "per_booking", "included", "free", "on_request"]),
+    sellAmountCents: z.number().int().min(0).nullable().optional(),
+    costAmountCents: z.number().int().min(0).nullable().optional(),
+    minQuantity: z.number().int().min(0).nullable().optional(),
+    maxQuantity: z.number().int().min(0).nullable().optional(),
+    active: z.boolean().optional(),
+    sortOrder: z.number().int().optional(),
+    notes: z.string().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+});
+export function useOptionUnitPriceRuleMutation() {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/pricing/option-unit-price-rules", optionUnitPriceRuleSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionUnitPriceRules() });
+            queryClient.setQueryData(pricingQueryKeys.optionUnitPriceRule(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/pricing/option-unit-price-rules/${id}`, optionUnitPriceRuleSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionUnitPriceRules() });
+            queryClient.setQueryData(pricingQueryKeys.optionUnitPriceRule(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/pricing/option-unit-price-rules/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionUnitPriceRules() });
+            queryClient.removeQueries({ queryKey: pricingQueryKeys.optionUnitPriceRule(id) });
+        },
+    });
+    return { create, update, remove };
+}

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

@@ -0,0 +1,19 @@
+export interface UseOptionUnitPriceRuleOptions {
+    enabled?: boolean;
+}
+export declare function useOptionUnitPriceRule(id: string | null | undefined, options?: UseOptionUnitPriceRuleOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    optionPriceRuleId: string;
+    optionId: string;
+    unitId: string;
+    pricingCategoryId: string | null;
+    pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "free" | "per_unit";
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    minQuantity: number | null;
+    maxQuantity: number | null;
+    sortOrder: number;
+    active: boolean;
+    notes: string | null;
+}, Error>;
+//# sourceMappingURL=use-option-unit-price-rule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-unit-price-rule.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-unit-price-rule.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,6BAA6B;IAC5C,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7B,OAAO,GAAE,6BAAkC;;;;;;;;;;;;;;UAS5C"}

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

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantPricingContext } from "../provider.js";
+import { getOptionUnitPriceRuleQueryOptions } from "../query-options.js";
+export function useOptionUnitPriceRule(id, options = {}) {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getOptionUnitPriceRuleQueryOptions({ baseUrl, fetcher }, id ?? "__missing__"),
+        enabled: enabled && Boolean(id),
+    });
+}

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

@@ -0,0 +1,25 @@
+import type { OptionUnitPriceRulesListFilters } from "../query-keys.js";
+export interface UseOptionUnitPriceRulesOptions extends OptionUnitPriceRulesListFilters {
+    enabled?: boolean;
+}
+export declare function useOptionUnitPriceRules(options?: UseOptionUnitPriceRulesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        unitId: string;
+        pricingCategoryId: string | null;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "free" | "per_unit";
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        sortOrder: number;
+        active: boolean;
+        notes: string | null;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-option-unit-price-rules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-unit-price-rules.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-unit-price-rules.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,kBAAkB,CAAA;AAGvE,MAAM,WAAW,8BAA+B,SAAQ,+BAA+B;IACrF,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,8BAAmC;;;;;;;;;;;;;;;;;;;UAQnF"}

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

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

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

@@ -0,0 +1,50 @@
+import { z } from "zod";
+declare const optionUnitTierInputSchema: z.ZodObject<{
+    optionUnitPriceRuleId: z.ZodString;
+    minQuantity: z.ZodNumber;
+    maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type CreateOptionUnitTierInput = z.input<typeof optionUnitTierInputSchema>;
+export type UpdateOptionUnitTierInput = Partial<CreateOptionUnitTierInput>;
+export declare function useOptionUnitTierMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        optionUnitPriceRuleId: string;
+        minQuantity: number;
+        maxQuantity: number | null;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        active: boolean;
+        sortOrder: number;
+    }, Error, {
+        optionUnitPriceRuleId: string;
+        minQuantity: number;
+        maxQuantity?: number | null | undefined;
+        sellAmountCents?: number | null | undefined;
+        costAmountCents?: number | null | undefined;
+        active?: boolean | undefined;
+        sortOrder?: number | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        optionUnitPriceRuleId: string;
+        minQuantity: number;
+        maxQuantity: number | null;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        active: boolean;
+        sortOrder: number;
+    }, Error, {
+        id: string;
+        input: UpdateOptionUnitTierInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+export {};
+//# sourceMappingURL=use-option-unit-tier-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-unit-tier-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-unit-tier-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,yBAAyB;;;;;;;;iBAQ7B,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACjF,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAA;AAE1E,wBAAgB,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBG,MAAM;eAAS,yBAAyB;;;;;EA8BnF"}

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

@@ -0,0 +1,48 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { z } from "zod";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantPricingContext } from "../provider.js";
+import { pricingQueryKeys } from "../query-keys.js";
+import { optionUnitTierSingleResponse, successEnvelope } from "../schemas.js";
+const optionUnitTierInputSchema = z.object({
+    optionUnitPriceRuleId: z.string(),
+    minQuantity: z.number().int().min(1),
+    maxQuantity: z.number().int().min(1).nullable().optional(),
+    sellAmountCents: z.number().int().min(0).nullable().optional(),
+    costAmountCents: z.number().int().min(0).nullable().optional(),
+    active: z.boolean().optional(),
+    sortOrder: z.number().int().optional(),
+});
+export function useOptionUnitTierMutation() {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/pricing/option-unit-tiers", optionUnitTierSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionUnitTiers() });
+            queryClient.setQueryData(pricingQueryKeys.optionUnitTier(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/pricing/option-unit-tiers/${id}`, optionUnitTierSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionUnitTiers() });
+            queryClient.setQueryData(pricingQueryKeys.optionUnitTier(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/pricing/option-unit-tiers/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionUnitTiers() });
+            queryClient.removeQueries({ queryKey: pricingQueryKeys.optionUnitTier(id) });
+        },
+    });
+    return { create, update, remove };
+}

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

@@ -0,0 +1,14 @@
+export interface UseOptionUnitTierOptions {
+    enabled?: boolean;
+}
+export declare function useOptionUnitTier(id: string | null | undefined, options?: UseOptionUnitTierOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    optionUnitPriceRuleId: string;
+    minQuantity: number;
+    maxQuantity: number | null;
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    active: boolean;
+    sortOrder: number;
+}, Error>;
+//# sourceMappingURL=use-option-unit-tier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-unit-tier.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-unit-tier.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,wBAAwB;IACvC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7B,OAAO,GAAE,wBAA6B;;;;;;;;;UASvC"}

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

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantPricingContext } from "../provider.js";
+import { getOptionUnitTierQueryOptions } from "../query-options.js";
+export function useOptionUnitTier(id, options = {}) {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getOptionUnitTierQueryOptions({ baseUrl, fetcher }, id ?? "__missing__"),
+        enabled: enabled && Boolean(id),
+    });
+}

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

@@ -0,0 +1,20 @@
+import type { OptionUnitTiersListFilters } from "../query-keys.js";
+export interface UseOptionUnitTiersOptions extends OptionUnitTiersListFilters {
+    enabled?: boolean;
+}
+export declare function useOptionUnitTiers(options?: UseOptionUnitTiersOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        optionUnitPriceRuleId: string;
+        minQuantity: number;
+        maxQuantity: number | null;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        active: boolean;
+        sortOrder: number;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-option-unit-tiers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-unit-tiers.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-unit-tiers.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAA;AAGlE,MAAM,WAAW,yBAA0B,SAAQ,0BAA0B;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,yBAA8B;;;;;;;;;;;;;;UAQzE"}

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

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