@voyantjs/legal-react 0.2.0

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

@@ -0,0 +1,63 @@
+import type { insertPolicyAssignmentSchema, updatePolicyAssignmentSchema } from "@voyantjs/legal/policies/validation";
+import type { z } from "zod";
+export type CreateLegalPolicyAssignmentInput = z.input<typeof insertPolicyAssignmentSchema>;
+export type UpdateLegalPolicyAssignmentInput = z.input<typeof updatePolicyAssignmentSchema>;
+export declare function useLegalPolicyAssignmentMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        policyId: string;
+        scope: "supplier" | "channel" | "product" | "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;
+    }, Error, {
+        policyId: string;
+        scope: "supplier" | "channel" | "product" | "market" | "organization" | "global";
+        productId?: string | null | undefined;
+        channelId?: string | null | undefined;
+        supplierId?: string | null | undefined;
+        marketId?: string | null | undefined;
+        organizationId?: string | null | undefined;
+        validFrom?: string | null | undefined;
+        validTo?: string | null | undefined;
+        priority?: number | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        policyId: string;
+        scope: "supplier" | "channel" | "product" | "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;
+    }, Error, {
+        id: string;
+        input: UpdateLegalPolicyAssignmentInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        policyId: string;
+        data: {
+            success: boolean;
+        };
+    }, Error, {
+        policyId: string;
+        id: string;
+    }, unknown>;
+};
+//# sourceMappingURL=use-policy-assignment-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-policy-assignment-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-policy-assignment-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,4BAA4B,EAC5B,4BAA4B,EAC7B,MAAM,qCAAqC,CAAA;AAC5C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAM5B,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAC3F,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAE3F,wBAAgB,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAsBJ,MAAM;eAAS,gCAAgC;;;;;;;;kBAiBtC,MAAM;YAAM,MAAM;;EAetE"}

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

@@ -0,0 +1,41 @@
+"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 { legalPolicyAssignmentSingleResponse, successEnvelope } from "../schemas.js";
+export function useLegalPolicyAssignmentMutation() {
+    const { baseUrl, fetcher } = useVoyantLegalContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/admin/legal/policies/assignments", legalPolicyAssignmentSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({
+                queryKey: legalQueryKeys.policyAssignments({ policyId: data.policyId }),
+            });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/policies/assignments/${id}`, legalPolicyAssignmentSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({
+                queryKey: legalQueryKeys.policyAssignments({ policyId: data.policyId }),
+            });
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async ({ policyId, id }) => fetchWithValidation(`/v1/admin/legal/policies/assignments/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }).then((data) => ({ policyId, data })),
+        onSuccess: ({ policyId }) => {
+            void queryClient.invalidateQueries({
+                queryKey: legalQueryKeys.policyAssignments({ policyId }),
+            });
+        },
+    });
+    return { create, update, remove };
+}

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

@@ -0,0 +1,23 @@
+import type { LegalPolicyAssignmentsListFilters } from "../query-keys.js";
+export interface UseLegalPolicyAssignmentsOptions extends LegalPolicyAssignmentsListFilters {
+    enabled?: boolean;
+}
+export declare function useLegalPolicyAssignments(options?: UseLegalPolicyAssignmentsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        policyId: string;
+        scope: "supplier" | "channel" | "product" | "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;
+    }[];
+}, Error>;
+//# sourceMappingURL=use-policy-assignments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-policy-assignments.d.ts","sourceRoot":"","sources":["../../src/hooks/use-policy-assignments.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,kBAAkB,CAAA;AAGzE,MAAM,WAAW,gCAAiC,SAAQ,iCAAiC;IACzF,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,gCAAqC;;;;;;;;;;;;;;;;;UAOvF"}

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

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

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

@@ -0,0 +1,44 @@
+import type { insertPolicySchema, updatePolicySchema } from "@voyantjs/legal/policies/validation";
+import type { z } from "zod";
+export type CreateLegalPolicyInput = z.input<typeof insertPolicySchema>;
+export type UpdateLegalPolicyInput = z.input<typeof updatePolicySchema>;
+export declare function useLegalPolicyMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        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, {
+        kind: "other" | "cancellation" | "payment" | "terms_and_conditions" | "privacy" | "refund" | "commission" | "guarantee";
+        name: string;
+        slug: string;
+        description?: string | null | undefined;
+        language?: string | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        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, {
+        id: string;
+        input: UpdateLegalPolicyInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-policy-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-policy-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-policy-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAA;AACjG,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAM5B,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACvE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEvE,wBAAgB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBM,MAAM;eAAS,sBAAsB;;;;;EAgChF"}

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 "@voyantjs/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,qCAAqC,CAAA;AAC5C,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,73 @@
+import type { insertPolicyVersionSchema, updatePolicyVersionSchema } from "@voyantjs/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;
+        bodyFormat: "markdown" | "html" | "plain";
+        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;
+        bodyFormat: "markdown" | "html" | "plain";
+        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;
+        bodyFormat: "markdown" | "html" | "plain";
+        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;
+        bodyFormat: "markdown" | "html" | "plain";
+        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,qCAAqC,CAAA;AAC5C,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,20 @@
+export interface UseLegalPolicyVersionsOptions {
+    policyId: string;
+    enabled?: boolean;
+}
+export declare function useLegalPolicyVersions(options: UseLegalPolicyVersionsOptions): import("@tanstack/react-query").UseQueryResult<{
+    title: string;
+    bodyFormat: "markdown" | "html" | "plain";
+    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/index.d.ts

@@ -0,0 +1,7 @@
+export { defaultFetcher, type FetchWithValidationOptions, fetchWithValidation, VoyantApiError, type VoyantFetcher, } from "./client.js";
+export * from "./hooks/index.js";
+export { useVoyantLegalContext, type VoyantLegalContextValue, VoyantLegalProvider, type VoyantLegalProviderProps, } from "./provider.js";
+export { type LegalContractNumberSeriesListFilters, type LegalContractsListFilters, type LegalContractTemplatesListFilters, type LegalPoliciesListFilters, type LegalPolicyAcceptancesListFilters, type LegalPolicyAssignmentsListFilters, legalQueryKeys, } from "./query-keys.js";
+export { getLegalContractAttachmentsQueryOptions, getLegalContractNumberSeriesDetailQueryOptions, getLegalContractNumberSeriesQueryOptions, getLegalContractQueryOptions, getLegalContractSignaturesQueryOptions, getLegalContractsQueryOptions, getLegalContractTemplateQueryOptions, getLegalContractTemplatesQueryOptions, getLegalContractTemplateVersionsQueryOptions, getLegalPoliciesQueryOptions, getLegalPolicyAcceptancesQueryOptions, getLegalPolicyAssignmentsQueryOptions, getLegalPolicyQueryOptions, getLegalPolicyRulesQueryOptions, getLegalPolicyVersionQueryOptions, getLegalPolicyVersionsQueryOptions, } from "./query-options.js";
+export * from "./schemas.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,0BAA0B,EAC/B,mBAAmB,EACnB,cAAc,EACd,KAAK,aAAa,GACnB,MAAM,aAAa,CAAA;AACpB,cAAc,kBAAkB,CAAA;AAChC,OAAO,EACL,qBAAqB,EACrB,KAAK,uBAAuB,EAC5B,mBAAmB,EACnB,KAAK,wBAAwB,GAC9B,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,KAAK,oCAAoC,EACzC,KAAK,yBAAyB,EAC9B,KAAK,iCAAiC,EACtC,KAAK,wBAAwB,EAC7B,KAAK,iCAAiC,EACtC,KAAK,iCAAiC,EACtC,cAAc,GACf,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,uCAAuC,EACvC,8CAA8C,EAC9C,wCAAwC,EACxC,4BAA4B,EAC5B,sCAAsC,EACtC,6BAA6B,EAC7B,oCAAoC,EACpC,qCAAqC,EACrC,4CAA4C,EAC5C,4BAA4B,EAC5B,qCAAqC,EACrC,qCAAqC,EACrC,0BAA0B,EAC1B,+BAA+B,EAC/B,iCAAiC,EACjC,kCAAkC,GACnC,MAAM,oBAAoB,CAAA;AAC3B,cAAc,cAAc,CAAA"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { defaultFetcher, fetchWithValidation, VoyantApiError, } from "./client.js";
+export * from "./hooks/index.js";
+export { useVoyantLegalContext, VoyantLegalProvider, } from "./provider.js";
+export { legalQueryKeys, } from "./query-keys.js";
+export { getLegalContractAttachmentsQueryOptions, getLegalContractNumberSeriesDetailQueryOptions, getLegalContractNumberSeriesQueryOptions, getLegalContractQueryOptions, getLegalContractSignaturesQueryOptions, getLegalContractsQueryOptions, getLegalContractTemplateQueryOptions, getLegalContractTemplatesQueryOptions, getLegalContractTemplateVersionsQueryOptions, getLegalPoliciesQueryOptions, getLegalPolicyAcceptancesQueryOptions, getLegalPolicyAssignmentsQueryOptions, getLegalPolicyQueryOptions, getLegalPolicyRulesQueryOptions, getLegalPolicyVersionQueryOptions, getLegalPolicyVersionsQueryOptions, } from "./query-options.js";
+export * from "./schemas.js";

package/dist/provider.d.ts

@@ -0,0 +1,2 @@
+export { useVoyantReactContext as useVoyantLegalContext, type VoyantReactContextValue as VoyantLegalContextValue, VoyantReactProvider as VoyantLegalProvider, type VoyantReactProviderProps as VoyantLegalProviderProps, } from "@voyantjs/react";
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,IAAI,qBAAqB,EAC9C,KAAK,uBAAuB,IAAI,uBAAuB,EACvD,mBAAmB,IAAI,mBAAmB,EAC1C,KAAK,wBAAwB,IAAI,wBAAwB,GAC1D,MAAM,iBAAiB,CAAA"}

package/dist/provider.js

@@ -0,0 +1 @@
+export { useVoyantReactContext as useVoyantLegalContext, VoyantReactProvider as VoyantLegalProvider, } from "@voyantjs/react";