@voyant-travel/legal-react 0.119.2

package/dist/hooks/use-policy-mutation.js

@@ -0,0 +1,40 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantLegalContext } from "../provider.js";
+import { legalQueryKeys } from "../query-keys.js";
+import { legalPolicySingleResponse, successEnvelope } from "../schemas.js";
+export function useLegalPolicyMutation() {
+    const { baseUrl, fetcher } = useVoyantLegalContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/admin/legal/policies", legalPolicySingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.policies() });
+            queryClient.setQueryData(legalQueryKeys.policy(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/policies/${id}`, legalPolicySingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.policies() });
+            queryClient.setQueryData(legalQueryKeys.policy(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/admin/legal/policies/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.policies() });
+            queryClient.removeQueries({ queryKey: legalQueryKeys.policy(id) });
+            queryClient.removeQueries({ queryKey: legalQueryKeys.policyVersions(id) });
+            queryClient.removeQueries({ queryKey: legalQueryKeys.policyAssignments({ policyId: id }) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-policy-rule-mutation.d.ts

@@ -0,0 +1,56 @@
+import type { insertPolicyRuleSchema, updatePolicyRuleSchema } from "@voyant-travel/legal/policies/validation";
+import type { z } from "zod";
+export type CreateLegalPolicyRuleInput = z.input<typeof insertPolicyRuleSchema>;
+export type UpdateLegalPolicyRuleInput = z.input<typeof updatePolicyRuleSchema>;
+export declare function useLegalPolicyRuleMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        ruleType: "custom" | "window" | "percentage" | "flat_amount" | "date_range";
+        sortOrder: number;
+        id: string;
+        policyVersionId: string;
+        label: string | null;
+        daysBeforeDeparture: number | null;
+        refundPercent: number | null;
+        flatAmountCents: number | null;
+        currency: string | null;
+        createdAt: string;
+        updatedAt: string;
+        refundType?: "cash" | "credit" | "cash_or_credit" | "none" | null | undefined;
+        validFrom?: string | null | undefined;
+        validTo?: string | null | undefined;
+        conditions?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        versionId: string;
+        input: CreateLegalPolicyRuleInput;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        ruleType: "custom" | "window" | "percentage" | "flat_amount" | "date_range";
+        sortOrder: number;
+        id: string;
+        policyVersionId: string;
+        label: string | null;
+        daysBeforeDeparture: number | null;
+        refundPercent: number | null;
+        flatAmountCents: number | null;
+        currency: string | null;
+        createdAt: string;
+        updatedAt: string;
+        refundType?: "cash" | "credit" | "cash_or_credit" | "none" | null | undefined;
+        validFrom?: string | null | undefined;
+        validTo?: string | null | undefined;
+        conditions?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateLegalPolicyRuleInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        versionId: string;
+        data: {
+            success: boolean;
+        };
+    }, Error, {
+        versionId: string;
+        id: string;
+    }, unknown>;
+};
+//# sourceMappingURL=use-policy-rule-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-policy-rule-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-policy-rule-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,0CAA0C,CAAA;AACjD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAM5B,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC/E,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE/E,wBAAgB,0BAA0B;;;;;;;;;;;;;;;;;;mBASzB,MAAM;eACV,0BAA0B;;;;;;;;;;;;;;;;;;;YAkBK,MAAM;eAAS,0BAA0B;;;;;;;;mBAiB9B,MAAM;YAAM,MAAM;;EAaxE"}

package/dist/hooks/use-policy-rule-mutation.js

@@ -0,0 +1,39 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantLegalContext } from "../provider.js";
+import { legalQueryKeys } from "../query-keys.js";
+import { legalPolicyRuleSingleResponse, successEnvelope } from "../schemas.js";
+export function useLegalPolicyRuleMutation() {
+    const { baseUrl, fetcher } = useVoyantLegalContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async ({ versionId, input, }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/policies/versions/${versionId}/rules`, legalPolicyRuleSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({
+                queryKey: legalQueryKeys.policyRules(data.policyVersionId),
+            });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/policies/rules/${id}`, legalPolicyRuleSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({
+                queryKey: legalQueryKeys.policyRules(data.policyVersionId),
+            });
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async ({ versionId, id }) => fetchWithValidation(`/v1/admin/legal/policies/rules/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }).then((data) => ({ versionId, data })),
+        onSuccess: ({ versionId }) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.policyRules(versionId) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-policy-rules.d.ts

@@ -0,0 +1,22 @@
+export interface UseLegalPolicyRulesOptions {
+    versionId: string;
+    enabled?: boolean;
+}
+export declare function useLegalPolicyRules(options: UseLegalPolicyRulesOptions): import("@tanstack/react-query").UseQueryResult<{
+    ruleType: "custom" | "window" | "percentage" | "flat_amount" | "date_range";
+    sortOrder: number;
+    id: string;
+    policyVersionId: string;
+    label: string | null;
+    daysBeforeDeparture: number | null;
+    refundPercent: number | null;
+    flatAmountCents: number | null;
+    currency: string | null;
+    createdAt: string;
+    updatedAt: string;
+    refundType?: "cash" | "credit" | "cash_or_credit" | "none" | null | undefined;
+    validFrom?: string | null | undefined;
+    validTo?: string | null | undefined;
+    conditions?: Record<string, unknown> | null | undefined;
+}[], Error>;
+//# sourceMappingURL=use-policy-rules.d.ts.map

package/dist/hooks/use-policy-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-policy-rules.d.ts","sourceRoot":"","sources":["../../src/hooks/use-policy-rules.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B;;;;;;;;;;;;;;;;YAOtE"}

package/dist/hooks/use-policy-rules.js

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

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

@@ -0,0 +1,69 @@
+import type { insertPolicyVersionSchema, updatePolicyVersionSchema } from "@voyant-travel/legal/policies/validation";
+import type { z } from "zod";
+export type CreateLegalPolicyVersionInput = z.input<typeof insertPolicyVersionSchema>;
+export type UpdateLegalPolicyVersionInput = z.input<typeof updatePolicyVersionSchema>;
+export declare function useLegalPolicyVersionMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        title: string;
+        id: string;
+        policyId: string;
+        version: number;
+        status: "draft" | "published" | "retired";
+        body: string | null;
+        publishedAt: string | null;
+        publishedBy: string | null;
+        createdAt: string;
+        updatedAt: string;
+        retiredAt?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        policyId: string;
+        input: CreateLegalPolicyVersionInput;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        title: string;
+        id: string;
+        policyId: string;
+        version: number;
+        status: "draft" | "published" | "retired";
+        body: string | null;
+        publishedAt: string | null;
+        publishedBy: string | null;
+        createdAt: string;
+        updatedAt: string;
+        retiredAt?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateLegalPolicyVersionInput;
+    }, unknown>;
+    publish: import("@tanstack/react-query").UseMutationResult<{
+        title: string;
+        id: string;
+        policyId: string;
+        version: number;
+        status: "draft" | "published" | "retired";
+        body: string | null;
+        publishedAt: string | null;
+        publishedBy: string | null;
+        createdAt: string;
+        updatedAt: string;
+        retiredAt?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, string, unknown>;
+    retire: import("@tanstack/react-query").UseMutationResult<{
+        title: string;
+        id: string;
+        policyId: string;
+        version: number;
+        status: "draft" | "published" | "retired";
+        body: string | null;
+        publishedAt: string | null;
+        publishedBy: string | null;
+        createdAt: string;
+        updatedAt: string;
+        retiredAt?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-policy-version-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-policy-version-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-policy-version-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,yBAAyB,EACzB,yBAAyB,EAC1B,MAAM,0CAA0C,CAAA;AACjD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAM5B,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACrF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAErF,wBAAgB,6BAA6B;;;;;;;;;;;;;;;kBAS7B,MAAM;eACT,6BAA6B;;;;;;;;;;;;;;;;YAgBE,MAAM;eAAS,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDvF"}

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

@@ -0,0 +1,50 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantLegalContext } from "../provider.js";
+import { legalQueryKeys } from "../query-keys.js";
+import { legalPolicyVersionSingleResponse } from "../schemas.js";
+export function useLegalPolicyVersionMutation() {
+    const { baseUrl, fetcher } = useVoyantLegalContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async ({ policyId, input, }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/policies/${policyId}/versions`, legalPolicyVersionSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.policyVersions(data.policyId) });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/policies/versions/${id}`, legalPolicyVersionSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.policyVersions(data.policyId) });
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.policy(data.policyId) });
+        },
+    });
+    const publish = useMutation({
+        mutationFn: async (id) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/policies/versions/${id}/publish`, legalPolicyVersionSingleResponse, { baseUrl, fetcher }, { method: "POST" });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.policyVersions(data.policyId) });
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.policy(data.policyId) });
+        },
+    });
+    const retire = useMutation({
+        mutationFn: async (id) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/policies/versions/${id}/retire`, legalPolicyVersionSingleResponse, { baseUrl, fetcher }, { method: "POST" });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.policyVersions(data.policyId) });
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.policy(data.policyId) });
+        },
+    });
+    return { create, update, publish, retire };
+}

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

@@ -0,0 +1,19 @@
+export interface UseLegalPolicyVersionsOptions {
+    policyId: string;
+    enabled?: boolean;
+}
+export declare function useLegalPolicyVersions(options: UseLegalPolicyVersionsOptions): import("@tanstack/react-query").UseQueryResult<{
+    title: string;
+    id: string;
+    policyId: string;
+    version: number;
+    status: "draft" | "published" | "retired";
+    body: string | null;
+    publishedAt: string | null;
+    publishedBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+    retiredAt?: string | null | undefined;
+    metadata?: Record<string, unknown> | null | undefined;
+}[], Error>;
+//# sourceMappingURL=use-policy-versions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-policy-versions.d.ts","sourceRoot":"","sources":["../../src/hooks/use-policy-versions.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,6BAA6B;;;;;;;;;;;;;YAO5E"}

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

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

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

@@ -0,0 +1,16 @@
+export interface UseLegalPolicyOptions {
+    enabled?: boolean;
+}
+export declare function useLegalPolicy(id: string, options?: UseLegalPolicyOptions): import("@tanstack/react-query").UseQueryResult<{
+    kind: "other" | "cancellation" | "payment" | "terms_and_conditions" | "privacy" | "refund" | "commission" | "guarantee";
+    name: string;
+    slug: string;
+    language: string;
+    id: string;
+    description: string | null;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown> | null | undefined;
+    currentVersionId?: string | null | undefined;
+}, Error>;
+//# sourceMappingURL=use-policy.d.ts.map

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

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

package/dist/hooks/use-policy.js

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

package/dist/hooks/use-resolve-policy.d.ts

@@ -0,0 +1,72 @@
+import type { ResolvePolicyFilters } from "../query-keys.js";
+export interface UseResolvePolicyOptions {
+    enabled?: boolean;
+}
+/**
+ * Resolves the applicable policy for the given scope (kind + productId, channelId, etc.).
+ * Typically used with `kind: "cancellation"` to find the policy that applies to a booking.
+ */
+export declare function useResolvePolicy(filters: ResolvePolicyFilters, options?: UseResolvePolicyOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        policy: {
+            kind: "other" | "cancellation" | "payment" | "terms_and_conditions" | "privacy" | "refund" | "commission" | "guarantee";
+            name: string;
+            slug: string;
+            language: string;
+            id: string;
+            description: string | null;
+            createdAt: string;
+            updatedAt: string;
+            metadata?: Record<string, unknown> | null | undefined;
+            currentVersionId?: string | null | undefined;
+        };
+        assignment: {
+            policyId: string;
+            scope: "product" | "supplier" | "channel" | "market" | "organization" | "global";
+            priority: number;
+            id: string;
+            productId: string | null;
+            channelId: string | null;
+            supplierId: string | null;
+            marketId: string | null;
+            organizationId: string | null;
+            createdAt: string;
+            updatedAt: string;
+            validFrom?: string | null | undefined;
+            validTo?: string | null | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        };
+        version: {
+            title: string;
+            id: string;
+            policyId: string;
+            version: number;
+            status: "draft" | "published" | "retired";
+            body: string | null;
+            publishedAt: string | null;
+            publishedBy: string | null;
+            createdAt: string;
+            updatedAt: string;
+            retiredAt?: string | null | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        } | null;
+        rules: {
+            ruleType: "custom" | "window" | "percentage" | "flat_amount" | "date_range";
+            sortOrder: number;
+            id: string;
+            policyVersionId: string;
+            label: string | null;
+            daysBeforeDeparture: number | null;
+            refundPercent: number | null;
+            flatAmountCents: number | null;
+            currency: string | null;
+            createdAt: string;
+            updatedAt: string;
+            refundType?: "cash" | "credit" | "cash_or_credit" | "none" | null | undefined;
+            validFrom?: string | null | undefined;
+            validTo?: string | null | undefined;
+            conditions?: Record<string, unknown> | null | undefined;
+        }[];
+    } | null;
+}, Error>;
+//# sourceMappingURL=use-resolve-policy.d.ts.map

package/dist/hooks/use-resolve-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-resolve-policy.d.ts","sourceRoot":"","sources":["../../src/hooks/use-resolve-policy.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAG5D,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,oBAAoB,EAC7B,OAAO,GAAE,uBAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAStC"}

package/dist/hooks/use-resolve-policy.js

@@ -0,0 +1,16 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantLegalContext } from "../provider.js";
+import { getResolvePolicyQueryOptions } from "../query-options.js";
+/**
+ * Resolves the applicable policy for the given scope (kind + productId, channelId, etc.).
+ * Typically used with `kind: "cancellation"` to find the policy that applies to a booking.
+ */
+export function useResolvePolicy(filters, options = {}) {
+    const { baseUrl, fetcher } = useVoyantLegalContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getResolvePolicyQueryOptions({ baseUrl, fetcher }, filters),
+        enabled: enabled && Boolean(filters.kind),
+    });
+}

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

@@ -0,0 +1,27 @@
+export interface UseLegalTermOptions {
+    enabled?: boolean;
+}
+export declare function useLegalTerm(id: string, options?: UseLegalTermOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    termType: "other" | "cancellation" | "payment" | "terms_and_conditions" | "commission" | "guarantee" | "pricing";
+    title: string;
+    body: string;
+    required: boolean;
+    sortOrder: number;
+    acceptanceStatus: "pending" | "not_required" | "accepted" | "declined";
+    createdAt: string;
+    updatedAt: string;
+    contractId?: string | null | undefined;
+    policyVersionId?: string | null | undefined;
+    targetKind?: "booking" | "quote_version" | "program" | "product" | "inventory_item" | "supplier_channel_relationship" | "provider_source_ref" | null | undefined;
+    targetId?: string | null | undefined;
+    targetProvider?: string | null | undefined;
+    targetSourceRef?: string | null | undefined;
+    legacyTransactionOfferId?: string | null | undefined;
+    legacyTransactionOrderId?: string | null | undefined;
+    language?: string | null | undefined;
+    acceptedAt?: string | null | undefined;
+    acceptedBy?: string | null | undefined;
+    metadata?: Record<string, unknown> | null | undefined;
+}, Error>;
+//# sourceMappingURL=use-term.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-term.d.ts","sourceRoot":"","sources":["../../src/hooks/use-term.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB;;;;;;;;;;;;;;;;;;;;;;UAQzE"}

package/dist/hooks/use-term.js

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

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

@@ -0,0 +1,33 @@
+import type { LegalTermsListFilters } from "../query-keys.js";
+export interface UseLegalTermsOptions extends LegalTermsListFilters {
+    enabled?: boolean;
+}
+export declare function useLegalTerms(options?: UseLegalTermsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        termType: "other" | "cancellation" | "payment" | "terms_and_conditions" | "commission" | "guarantee" | "pricing";
+        title: string;
+        body: string;
+        required: boolean;
+        sortOrder: number;
+        acceptanceStatus: "pending" | "not_required" | "accepted" | "declined";
+        createdAt: string;
+        updatedAt: string;
+        contractId?: string | null | undefined;
+        policyVersionId?: string | null | undefined;
+        targetKind?: "booking" | "quote_version" | "program" | "product" | "inventory_item" | "supplier_channel_relationship" | "provider_source_ref" | null | undefined;
+        targetId?: string | null | undefined;
+        targetProvider?: string | null | undefined;
+        targetSourceRef?: string | null | undefined;
+        legacyTransactionOfferId?: string | null | undefined;
+        legacyTransactionOrderId?: string | null | undefined;
+        language?: string | null | undefined;
+        acceptedAt?: string | null | undefined;
+        acceptedBy?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-terms.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-terms.d.ts","sourceRoot":"","sources":["../../src/hooks/use-terms.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AAG7D,MAAM,WAAW,oBAAqB,SAAQ,qBAAqB;IACjE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;UAQ/D"}

package/dist/hooks/use-terms.js

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