@voyantjs/pricing-react 0.2.0 → 0.3.1

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

@@ -0,0 +1,64 @@
+import { z } from "zod";
+declare const pickupPriceRuleInputSchema: z.ZodObject<{
+    optionPriceRuleId: z.ZodString;
+    optionId: z.ZodString;
+    pickupPointId: 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>>;
+}, z.core.$strip>;
+export type CreatePickupPriceRuleInput = z.input<typeof pickupPriceRuleInputSchema>;
+export type UpdatePickupPriceRuleInput = Partial<CreatePickupPriceRuleInput>;
+export declare function usePickupPriceRuleMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        pickupPointId: string;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "unavailable";
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        active: boolean;
+        sortOrder: number;
+        notes: string | null;
+    }, Error, {
+        optionPriceRuleId: string;
+        optionId: string;
+        pickupPointId: string;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "unavailable";
+        sellAmountCents?: number | null | undefined;
+        costAmountCents?: number | null | undefined;
+        active?: boolean | undefined;
+        sortOrder?: number | undefined;
+        notes?: string | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        pickupPointId: string;
+        pricingMode: "included" | "per_person" | "per_booking" | "on_request" | "unavailable";
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        active: boolean;
+        sortOrder: number;
+        notes: string | null;
+    }, Error, {
+        id: string;
+        input: UpdatePickupPriceRuleInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+export {};
+//# sourceMappingURL=use-pickup-price-rule-mutation.d.ts.map

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

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

@@ -0,0 +1,50 @@
+"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 { pickupPriceRuleSingleResponse, successEnvelope } from "../schemas.js";
+const pickupPriceRuleInputSchema = z.object({
+    optionPriceRuleId: z.string(),
+    optionId: z.string(),
+    pickupPointId: z.string(),
+    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 usePickupPriceRuleMutation() {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/pricing/pickup-price-rules", pickupPriceRuleSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.pickupPriceRules() });
+            queryClient.setQueryData(pricingQueryKeys.pickupPriceRule(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/pricing/pickup-price-rules/${id}`, pickupPriceRuleSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.pickupPriceRules() });
+            queryClient.setQueryData(pricingQueryKeys.pickupPriceRule(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/pricing/pickup-price-rules/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.pickupPriceRules() });
+            queryClient.removeQueries({ queryKey: pricingQueryKeys.pickupPriceRule(id) });
+        },
+    });
+    return { create, update, remove };
+}

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

@@ -0,0 +1,16 @@
+export interface UsePickupPriceRuleOptions {
+    enabled?: boolean;
+}
+export declare function usePickupPriceRule(id: string | null | undefined, options?: UsePickupPriceRuleOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    optionPriceRuleId: string;
+    optionId: string;
+    pickupPointId: 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-pickup-price-rule.d.ts.map

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

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

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

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

@@ -0,0 +1,22 @@
+import type { PickupPriceRulesListFilters } from "../query-keys.js";
+export interface UsePickupPriceRulesOptions extends PickupPriceRulesListFilters {
+    enabled?: boolean;
+}
+export declare function usePickupPriceRules(options?: UsePickupPriceRulesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        pickupPointId: 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-pickup-price-rules.d.ts.map

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

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

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

package/dist/hooks/use-price-catalog-mutation.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+declare const priceCatalogInputSchema: z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodString;
+    currencyCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    catalogType: z.ZodEnum<{
+        public: "public";
+        contract: "contract";
+        net: "net";
+        gross: "gross";
+        promo: "promo";
+        internal: "internal";
+        other: "other";
+    }>;
+    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 CreatePriceCatalogInput = z.input<typeof priceCatalogInputSchema>;
+export type UpdatePriceCatalogInput = Partial<CreatePriceCatalogInput>;
+export declare function usePriceCatalogMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        code: string;
+        name: string;
+        currencyCode: string;
+        catalogType: "public" | "contract" | "net" | "gross" | "promo" | "internal" | "other";
+        isDefault: boolean;
+        active: boolean;
+        notes: string | null;
+    }, Error, {
+        code: string;
+        name: string;
+        catalogType: "public" | "contract" | "net" | "gross" | "promo" | "internal" | "other";
+        currencyCode?: string | null | 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;
+        code: string;
+        name: string;
+        currencyCode: string;
+        catalogType: "public" | "contract" | "net" | "gross" | "promo" | "internal" | "other";
+        isDefault: boolean;
+        active: boolean;
+        notes: string | null;
+    }, Error, {
+        id: string;
+        input: UpdatePriceCatalogInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+export {};
+//# sourceMappingURL=use-price-catalog-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-price-catalog-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-price-catalog-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;iBAS3B,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAC7E,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAA;AAEtE,wBAAgB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBK,MAAM;eAAS,uBAAuB;;;;;EAgCjF"}

package/dist/hooks/use-price-catalog-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 { priceCatalogSingleResponse, successEnvelope } from "../schemas.js";
+const priceCatalogInputSchema = z.object({
+    code: z.string().min(1).max(100),
+    name: z.string().min(1).max(255),
+    currencyCode: z.string().length(3).nullable().optional(),
+    catalogType: z.enum(["public", "contract", "net", "gross", "promo", "internal", "other"]),
+    isDefault: z.boolean().optional(),
+    active: z.boolean().optional(),
+    notes: z.string().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+});
+export function usePriceCatalogMutation() {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/pricing/price-catalogs", priceCatalogSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.priceCatalogs() });
+            queryClient.setQueryData(pricingQueryKeys.priceCatalog(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/pricing/price-catalogs/${id}`, priceCatalogSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.priceCatalogs() });
+            queryClient.setQueryData(pricingQueryKeys.priceCatalog(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/pricing/price-catalogs/${id}`, successEnvelope, { baseUrl, fetcher }, {
+            method: "DELETE",
+        }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.priceCatalogs() });
+            queryClient.removeQueries({ queryKey: pricingQueryKeys.priceCatalog(id) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-price-catalog.d.ts

@@ -0,0 +1,14 @@
+export interface UsePriceCatalogOptions {
+    enabled?: boolean;
+}
+export declare function usePriceCatalog(id: string | null | undefined, options?: UsePriceCatalogOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    code: string;
+    name: string;
+    currencyCode: string;
+    catalogType: "public" | "contract" | "net" | "gross" | "promo" | "internal" | "other";
+    isDefault: boolean;
+    active: boolean;
+    notes: string | null;
+}, Error>;
+//# sourceMappingURL=use-price-catalog.d.ts.map

package/dist/hooks/use-price-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-price-catalog.d.ts","sourceRoot":"","sources":["../../src/hooks/use-price-catalog.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,sBAAsB;IACrC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7B,OAAO,GAAE,sBAA2B;;;;;;;;;UASrC"}

package/dist/hooks/use-price-catalog.js

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

package/dist/hooks/use-price-catalogs.d.ts

@@ -0,0 +1,20 @@
+import type { PriceCatalogsListFilters } from "../query-keys.js";
+export interface UsePriceCatalogsOptions extends PriceCatalogsListFilters {
+    enabled?: boolean;
+}
+export declare function usePriceCatalogs(options?: UsePriceCatalogsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        code: string;
+        name: string;
+        currencyCode: string;
+        catalogType: "public" | "contract" | "net" | "gross" | "promo" | "internal" | "other";
+        isDefault: boolean;
+        active: boolean;
+        notes: string | null;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-price-catalogs.d.ts.map

package/dist/hooks/use-price-catalogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-price-catalogs.d.ts","sourceRoot":"","sources":["../../src/hooks/use-price-catalogs.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAA;AAGhE,MAAM,WAAW,uBAAwB,SAAQ,wBAAwB;IACvE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,uBAA4B;;;;;;;;;;;;;;UAQrE"}

package/dist/hooks/use-price-catalogs.js

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

package/dist/hooks/use-price-schedule-mutation.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+declare const priceScheduleInputSchema: z.ZodObject<{
+    priceCatalogId: z.ZodString;
+    code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodString;
+    recurrenceRule: z.ZodString;
+    timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    weekdays: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
+        monday: "monday";
+        tuesday: "tuesday";
+        wednesday: "wednesday";
+        thursday: "thursday";
+        friday: "friday";
+        saturday: "saturday";
+        sunday: "sunday";
+    }>>>>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    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 CreatePriceScheduleInput = z.input<typeof priceScheduleInputSchema>;
+export type UpdatePriceScheduleInput = Partial<CreatePriceScheduleInput>;
+export declare function usePriceScheduleMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        priceCatalogId: string;
+        code: string | null;
+        name: string;
+        recurrenceRule: string;
+        timezone: string | null;
+        validFrom: string | null;
+        validTo: string | null;
+        weekdays: string[] | null;
+        priority: number;
+        active: boolean;
+        notes: string | null;
+    }, Error, {
+        priceCatalogId: string;
+        name: string;
+        recurrenceRule: string;
+        code?: string | null | undefined;
+        timezone?: string | null | undefined;
+        validFrom?: string | null | undefined;
+        validTo?: string | null | undefined;
+        weekdays?: ("monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday" | "sunday")[] | null | undefined;
+        priority?: number | undefined;
+        active?: boolean | undefined;
+        notes?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        priceCatalogId: string;
+        code: string | null;
+        name: string;
+        recurrenceRule: string;
+        timezone: string | null;
+        validFrom: string | null;
+        validTo: string | null;
+        weekdays: string[] | null;
+        priority: number;
+        active: boolean;
+        notes: string | null;
+    }, Error, {
+        id: string;
+        input: UpdatePriceScheduleInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+export {};
+//# sourceMappingURL=use-price-schedule-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-price-schedule-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-price-schedule-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;iBAa5B,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAC/E,MAAM,MAAM,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAA;AAExE,wBAAgB,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBI,MAAM;eAAS,wBAAwB;;;;;EAgClF"}

package/dist/hooks/use-price-schedule-mutation.js

@@ -0,0 +1,64 @@
+"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 { priceScheduleSingleResponse, successEnvelope } from "../schemas.js";
+const weekdaySchema = z.enum([
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday",
+]);
+const priceScheduleInputSchema = z.object({
+    priceCatalogId: z.string(),
+    code: z.string().max(100).nullable().optional(),
+    name: z.string().min(1).max(255),
+    recurrenceRule: z.string().min(1),
+    timezone: z.string().max(100).nullable().optional(),
+    validFrom: z.string().nullable().optional(),
+    validTo: z.string().nullable().optional(),
+    weekdays: z.array(weekdaySchema).nullable().optional(),
+    priority: z.number().int().optional(),
+    active: z.boolean().optional(),
+    notes: z.string().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+});
+export function usePriceScheduleMutation() {
+    const { baseUrl, fetcher } = useVoyantPricingContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/pricing/price-schedules", priceScheduleSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.priceSchedules() });
+            queryClient.setQueryData(pricingQueryKeys.priceSchedule(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/pricing/price-schedules/${id}`, priceScheduleSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.priceSchedules() });
+            queryClient.setQueryData(pricingQueryKeys.priceSchedule(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/pricing/price-schedules/${id}`, successEnvelope, { baseUrl, fetcher }, {
+            method: "DELETE",
+        }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: pricingQueryKeys.priceSchedules() });
+            queryClient.removeQueries({ queryKey: pricingQueryKeys.priceSchedule(id) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-price-schedule.d.ts

@@ -0,0 +1,18 @@
+export interface UsePriceScheduleOptions {
+    enabled?: boolean;
+}
+export declare function usePriceSchedule(id: string | null | undefined, options?: UsePriceScheduleOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    priceCatalogId: string;
+    code: string | null;
+    name: string;
+    recurrenceRule: string;
+    timezone: string | null;
+    validFrom: string | null;
+    validTo: string | null;
+    weekdays: string[] | null;
+    priority: number;
+    active: boolean;
+    notes: string | null;
+}, Error>;
+//# sourceMappingURL=use-price-schedule.d.ts.map

package/dist/hooks/use-price-schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-price-schedule.d.ts","sourceRoot":"","sources":["../../src/hooks/use-price-schedule.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7B,OAAO,GAAE,uBAA4B;;;;;;;;;;;;;UAStC"}

package/dist/hooks/use-price-schedule.js

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

package/dist/hooks/use-price-schedules.d.ts

@@ -0,0 +1,28 @@
+export interface UsePriceSchedulesOptions {
+    priceCatalogId?: string | undefined;
+    active?: boolean | undefined;
+    search?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    enabled?: boolean | undefined;
+}
+export declare function usePriceSchedules(options?: UsePriceSchedulesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        priceCatalogId: string;
+        code: string | null;
+        name: string;
+        recurrenceRule: string;
+        timezone: string | null;
+        validFrom: string | null;
+        validTo: string | null;
+        weekdays: string[] | null;
+        priority: number;
+        active: boolean;
+        notes: string | null;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-price-schedules.d.ts.map

package/dist/hooks/use-price-schedules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-price-schedules.d.ts","sourceRoot":"","sources":["../../src/hooks/use-price-schedules.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,wBAAwB;IACvC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAC9B;AAED,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B;;;;;;;;;;;;;;;;;;UAOvE"}

package/dist/hooks/use-price-schedules.js

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

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

@@ -10,7 +10,7 @@ export declare function usePricingCategories(options?: UsePricingCategoriesOptio
         unitId: string | null;
         code: string | null;
         name: string;
-        categoryType: "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle" | "service" | "other";
+        categoryType: "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle" | "service";
         seatOccupancy: number;
         groupSize: number | null;
         isAgeQualified: boolean;

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;UAyB7E"}

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

@@ -21,6 +21,8 @@ export function usePricingCategories(options = {}) {
                 params.set("categoryType", filters.categoryType);
             if (filters.active !== undefined)
                 params.set("active", String(filters.active));
+            if (filters.search)
+                params.set("search", filters.search);
             if (filters.limit !== undefined)
                 params.set("limit", String(filters.limit));
             if (filters.offset !== undefined)