@voyantjs/pricing-react 0.2.0 → 0.3.1

package/dist/hooks/use-dropoff-price-rule-mutation.js

@@ -0,0 +1,52 @@
+"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 { dropoffPriceRuleSingleResponse, successEnvelope } from "../schemas.js";
+const dropoffPriceRuleInputSchema = z.object({
+    optionPriceRuleId: z.string(),
+    optionId: z.string(),
+    facilityId: z.string().nullable().optional(),
+    dropoffCode: z.string().max(100).nullable().optional(),
+    dropoffName: z.string().min(1).max(255),
+    pricingMode: z.enum(["included", "per_person", "per_booking", "on_request", "unavailable"]),
+    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(),
+    notes: z.string().nullable().optional(),
+});
+export function useDropoffPriceRuleMutation() {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/pricing/dropoff-price-rules", dropoffPriceRuleSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.dropoffPriceRules() });
+            queryClient.setQueryData(pricingQueryKeys.dropoffPriceRule(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/pricing/dropoff-price-rules/${id}`, dropoffPriceRuleSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.dropoffPriceRules() });
+            queryClient.setQueryData(pricingQueryKeys.dropoffPriceRule(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/pricing/dropoff-price-rules/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.dropoffPriceRules() });
+            queryClient.removeQueries({ queryKey: pricingQueryKeys.dropoffPriceRule(id) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-dropoff-price-rule.d.ts

@@ -0,0 +1,18 @@
+export interface UseDropoffPriceRuleOptions {
+    enabled?: boolean;
+}
+export declare function useDropoffPriceRule(id: string | null | undefined, options?: UseDropoffPriceRuleOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    optionPriceRuleId: string;
+    optionId: string;
+    facilityId: string | null;
+    dropoffCode: string | null;
+    dropoffName: string;
+    pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "unavailable";
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    active: boolean;
+    sortOrder: number;
+    notes: string | null;
+}, Error>;
+//# sourceMappingURL=use-dropoff-price-rule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-dropoff-price-rule.d.ts","sourceRoot":"","sources":["../../src/hooks/use-dropoff-price-rule.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7B,OAAO,GAAE,0BAA+B;;;;;;;;;;;;;UASzC"}

package/dist/hooks/use-dropoff-price-rule.js

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

package/dist/hooks/use-dropoff-price-rules.d.ts

@@ -0,0 +1,24 @@
+import type { DropoffPriceRulesListFilters } from "../query-keys.js";
+export interface UseDropoffPriceRulesOptions extends DropoffPriceRulesListFilters {
+    enabled?: boolean;
+}
+export declare function useDropoffPriceRules(options?: UseDropoffPriceRulesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        facilityId: string | null;
+        dropoffCode: string | null;
+        dropoffName: string;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "unavailable";
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        active: boolean;
+        sortOrder: number;
+        notes: string | null;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-dropoff-price-rules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-dropoff-price-rules.d.ts","sourceRoot":"","sources":["../../src/hooks/use-dropoff-price-rules.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAA;AAGpE,MAAM,WAAW,2BAA4B,SAAQ,4BAA4B;IAC/E,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,2BAAgC;;;;;;;;;;;;;;;;;;UAQ7E"}

package/dist/hooks/use-dropoff-price-rules.js

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

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

@@ -0,0 +1,72 @@
+import { z } from "zod";
+declare const extraPriceRuleInputSchema: z.ZodObject<{
+    optionPriceRuleId: z.ZodString;
+    optionId: z.ZodString;
+    productExtraId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    optionExtraConfigId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pricingMode: z.ZodEnum<{
+        included: "included";
+        per_person: "per_person";
+        per_booking: "per_booking";
+        on_request: "on_request";
+        unavailable: "unavailable";
+    }>;
+    sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    costAmountCents: 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 CreateExtraPriceRuleInput = z.input<typeof extraPriceRuleInputSchema>;
+export type UpdateExtraPriceRuleInput = Partial<CreateExtraPriceRuleInput>;
+export declare function useExtraPriceRuleMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        productExtraId: string | null;
+        optionExtraConfigId: string | null;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "unavailable";
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        active: boolean;
+        sortOrder: number;
+        notes: string | null;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        optionPriceRuleId: string;
+        optionId: string;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "unavailable";
+        productExtraId?: string | null | undefined;
+        optionExtraConfigId?: string | null | undefined;
+        sellAmountCents?: number | null | undefined;
+        costAmountCents?: 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;
+        productExtraId: string | null;
+        optionExtraConfigId: string | null;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "unavailable";
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        active: boolean;
+        sortOrder: number;
+        notes: string | null;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateExtraPriceRuleInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+export {};
+//# sourceMappingURL=use-extra-price-rule-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-extra-price-rule-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-extra-price-rule-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;iBAY7B,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-extra-price-rule-mutation.js

@@ -0,0 +1,52 @@
+"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 { extraPriceRuleSingleResponse, successEnvelope } from "../schemas.js";
+const extraPriceRuleInputSchema = z.object({
+    optionPriceRuleId: z.string(),
+    optionId: z.string(),
+    productExtraId: z.string().nullable().optional(),
+    optionExtraConfigId: z.string().nullable().optional(),
+    pricingMode: z.enum(["included", "per_person", "per_booking", "on_request", "unavailable"]),
+    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(),
+    notes: z.string().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+});
+export function useExtraPriceRuleMutation() {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/pricing/extra-price-rules", extraPriceRuleSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.extraPriceRules() });
+            queryClient.setQueryData(pricingQueryKeys.extraPriceRule(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/pricing/extra-price-rules/${id}`, extraPriceRuleSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.extraPriceRules() });
+            queryClient.setQueryData(pricingQueryKeys.extraPriceRule(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/pricing/extra-price-rules/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.extraPriceRules() });
+            queryClient.removeQueries({ queryKey: pricingQueryKeys.extraPriceRule(id) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-extra-price-rule.d.ts

@@ -0,0 +1,18 @@
+export interface UseExtraPriceRuleOptions {
+    enabled?: boolean;
+}
+export declare function useExtraPriceRule(id: string | null | undefined, options?: UseExtraPriceRuleOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    optionPriceRuleId: string;
+    optionId: string;
+    productExtraId: string | null;
+    optionExtraConfigId: string | null;
+    pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "unavailable";
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    active: boolean;
+    sortOrder: number;
+    notes: string | null;
+    metadata?: Record<string, unknown> | null | undefined;
+}, Error>;
+//# sourceMappingURL=use-extra-price-rule.d.ts.map

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

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

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

package/dist/hooks/use-extra-price-rules.d.ts

@@ -0,0 +1,24 @@
+import type { ExtraPriceRulesListFilters } from "../query-keys.js";
+export interface UseExtraPriceRulesOptions extends ExtraPriceRulesListFilters {
+    enabled?: boolean;
+}
+export declare function useExtraPriceRules(options?: UseExtraPriceRulesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        productExtraId: string | null;
+        optionExtraConfigId: string | null;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "unavailable";
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        active: boolean;
+        sortOrder: number;
+        notes: string | null;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-extra-price-rules.d.ts.map

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

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

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

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

@@ -0,0 +1,98 @@
+import { z } from "zod";
+declare const optionPriceRuleInputSchema: z.ZodObject<{
+    productId: z.ZodString;
+    optionId: z.ZodString;
+    priceCatalogId: z.ZodString;
+    priceScheduleId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    cancellationPolicyId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pricingMode: z.ZodEnum<{
+        per_person: "per_person";
+        per_booking: "per_booking";
+        on_request: "on_request";
+        starting_from: "starting_from";
+        free: "free";
+    }>;
+    baseSellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    baseCostAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    minPerBooking: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxPerBooking: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    allPricingCategories: z.ZodOptional<z.ZodBoolean>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export type CreateOptionPriceRuleInput = z.input<typeof optionPriceRuleInputSchema>;
+export type UpdateOptionPriceRuleInput = Partial<CreateOptionPriceRuleInput>;
+export declare function useOptionPriceRuleMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        optionId: string;
+        priceCatalogId: string;
+        priceScheduleId: string | null;
+        cancellationPolicyId: string | null;
+        code: string | null;
+        name: string;
+        description: string | null;
+        pricingMode: "per_person" | "per_booking" | "on_request" | "starting_from" | "free";
+        baseSellAmountCents: number | null;
+        baseCostAmountCents: number | null;
+        minPerBooking: number | null;
+        maxPerBooking: number | null;
+        allPricingCategories: boolean;
+        isDefault: boolean;
+        active: boolean;
+        notes: string | null;
+    }, Error, {
+        productId: string;
+        optionId: string;
+        priceCatalogId: string;
+        name: string;
+        pricingMode: "per_person" | "per_booking" | "on_request" | "starting_from" | "free";
+        priceScheduleId?: string | null | undefined;
+        cancellationPolicyId?: string | null | undefined;
+        code?: string | null | undefined;
+        description?: string | null | undefined;
+        baseSellAmountCents?: number | null | undefined;
+        baseCostAmountCents?: number | null | undefined;
+        minPerBooking?: number | null | undefined;
+        maxPerBooking?: number | null | undefined;
+        allPricingCategories?: boolean | undefined;
+        isDefault?: boolean | undefined;
+        active?: boolean | undefined;
+        notes?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        productId: string;
+        optionId: string;
+        priceCatalogId: string;
+        priceScheduleId: string | null;
+        cancellationPolicyId: string | null;
+        code: string | null;
+        name: string;
+        description: string | null;
+        pricingMode: "per_person" | "per_booking" | "on_request" | "starting_from" | "free";
+        baseSellAmountCents: number | null;
+        baseCostAmountCents: number | null;
+        minPerBooking: number | null;
+        maxPerBooking: number | null;
+        allPricingCategories: boolean;
+        isDefault: boolean;
+        active: boolean;
+        notes: string | null;
+    }, Error, {
+        id: string;
+        input: UpdateOptionPriceRuleInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+export {};
+//# sourceMappingURL=use-option-price-rule-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-price-rule-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-price-rule-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAevB,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB9B,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AACnF,MAAM,MAAM,0BAA0B,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAA;AAE5E,wBAAgB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBE,MAAM;eAAS,0BAA0B;;;;;EA8BpF"}

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

@@ -0,0 +1,66 @@
+"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 { optionPriceRuleSingleResponse, successEnvelope } from "../schemas.js";
+const optionPricingModeSchema = z.enum([
+    "per_person",
+    "per_booking",
+    "starting_from",
+    "free",
+    "on_request",
+]);
+const optionPriceRuleInputSchema = z.object({
+    productId: z.string(),
+    optionId: z.string(),
+    priceCatalogId: z.string(),
+    priceScheduleId: z.string().nullable().optional(),
+    cancellationPolicyId: z.string().nullable().optional(),
+    code: z.string().max(100).nullable().optional(),
+    name: z.string().min(1).max(255),
+    description: z.string().nullable().optional(),
+    pricingMode: optionPricingModeSchema,
+    baseSellAmountCents: z.number().int().min(0).nullable().optional(),
+    baseCostAmountCents: z.number().int().min(0).nullable().optional(),
+    minPerBooking: z.number().int().min(0).nullable().optional(),
+    maxPerBooking: z.number().int().min(0).nullable().optional(),
+    allPricingCategories: z.boolean().optional(),
+    isDefault: z.boolean().optional(),
+    active: z.boolean().optional(),
+    notes: z.string().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+});
+export function useOptionPriceRuleMutation() {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/pricing/option-price-rules", optionPriceRuleSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionPriceRules() });
+            queryClient.setQueryData(pricingQueryKeys.optionPriceRule(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/pricing/option-price-rules/${id}`, optionPriceRuleSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionPriceRules() });
+            queryClient.setQueryData(pricingQueryKeys.optionPriceRule(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/pricing/option-price-rules/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.optionPriceRules() });
+            queryClient.removeQueries({ queryKey: pricingQueryKeys.optionPriceRule(id) });
+        },
+    });
+    return { create, update, remove };
+}

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

@@ -0,0 +1,24 @@
+export interface UseOptionPriceRuleOptions {
+    enabled?: boolean;
+}
+export declare function useOptionPriceRule(id: string | null | undefined, options?: UseOptionPriceRuleOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    productId: string;
+    optionId: string;
+    priceCatalogId: string;
+    priceScheduleId: string | null;
+    cancellationPolicyId: string | null;
+    code: string | null;
+    name: string;
+    description: string | null;
+    pricingMode: "per_person" | "per_booking" | "on_request" | "starting_from" | "free";
+    baseSellAmountCents: number | null;
+    baseCostAmountCents: number | null;
+    minPerBooking: number | null;
+    maxPerBooking: number | null;
+    allPricingCategories: boolean;
+    isDefault: boolean;
+    active: boolean;
+    notes: string | null;
+}, Error>;
+//# sourceMappingURL=use-option-price-rule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-price-rule.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-price-rule.ts"],"names":[],"mappings":"AAOA,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;;;;;;;;;;;;;;;;;;;UASxC"}

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

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

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

@@ -0,0 +1,30 @@
+import type { OptionPriceRulesListFilters } from "../query-keys.js";
+export interface UseOptionPriceRulesOptions extends OptionPriceRulesListFilters {
+    enabled?: boolean;
+}
+export declare function useOptionPriceRules(options?: UseOptionPriceRulesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        productId: string;
+        optionId: string;
+        priceCatalogId: string;
+        priceScheduleId: string | null;
+        cancellationPolicyId: string | null;
+        code: string | null;
+        name: string;
+        description: string | null;
+        pricingMode: "per_person" | "per_booking" | "on_request" | "starting_from" | "free";
+        baseSellAmountCents: number | null;
+        baseCostAmountCents: number | null;
+        minPerBooking: number | null;
+        maxPerBooking: number | null;
+        allPricingCategories: boolean;
+        isDefault: boolean;
+        active: boolean;
+        notes: string | null;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-option-price-rules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-option-price-rules.d.ts","sourceRoot":"","sources":["../../src/hooks/use-option-price-rules.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAA;AAGnE,MAAM,WAAW,0BAA2B,SAAQ,2BAA2B;IAC7E,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,0BAA+B;;;;;;;;;;;;;;;;;;;;;;;;UAQ3E"}

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

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