@voyant-travel/legal-react 0.119.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-contract-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contract-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,mCAAmC,EACnC,qCAAqC,EACrC,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,2CAA2C,CAAA;AAClD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAY5B,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAC3E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAC3E,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AACpG,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,qCAAqC,CAC7C,CAAA;AAED,MAAM,WAAW,0BAA0B;IACzC,iDAAiD;IACjD,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,CAAC,EAAE,0BAA0B,CAAA;CACnC;AAED,wBAAgB,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBI,MAAM;eAAS,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkHzE,MAAM;gBACF,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;YA6BtC,MAAM;gBACF,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAwB/B,MAAM;gBACT,iCAAiC;;EAkC9C"}

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

@@ -0,0 +1,151 @@
+"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 { legalBookingContractGenerateDocumentResponse, legalContractGenerateDocumentResponse, legalContractSingleResponse, successEnvelope, } from "../schemas.js";
+export function useLegalContractMutation() {
+    const { baseUrl, fetcher } = useVoyantLegalContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/admin/legal/contracts", legalContractSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contracts() });
+            queryClient.setQueryData(legalQueryKeys.contract(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/contracts/${id}`, legalContractSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contracts() });
+            queryClient.setQueryData(legalQueryKeys.contract(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/admin/legal/contracts/${id}`, successEnvelope, { baseUrl, fetcher }, {
+            method: "DELETE",
+        }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contracts() });
+            queryClient.removeQueries({ queryKey: legalQueryKeys.contract(id) });
+            queryClient.removeQueries({ queryKey: legalQueryKeys.contractSignatures(id) });
+            queryClient.removeQueries({ queryKey: legalQueryKeys.contractAttachments(id) });
+        },
+    });
+    const issue = useMutation({
+        mutationFn: async (id) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/contracts/${id}/issue`, legalContractSingleResponse, { baseUrl, fetcher }, { method: "POST" });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contracts() });
+            queryClient.setQueryData(legalQueryKeys.contract(data.id), data);
+        },
+    });
+    const send = useMutation({
+        mutationFn: async (input) => {
+            // Back-compat: callers that just need the status flip can keep
+            // passing the id string. New callers (ContractSendDialog) pass
+            // `{ id, input: { subject, message, recipientEmail } }` so the
+            // route can carry their customization onto the `contract.sent`
+            // lifecycle event.
+            const normalized = typeof input === "string" ? { id: input, input: {} } : input;
+            const { data } = await fetchWithValidation(`/v1/admin/legal/contracts/${normalized.id}/send`, legalContractSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(normalized.input ?? {}) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contracts() });
+            queryClient.setQueryData(legalQueryKeys.contract(data.id), data);
+        },
+    });
+    const execute = useMutation({
+        mutationFn: async (id) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/contracts/${id}/execute`, legalContractSingleResponse, { baseUrl, fetcher }, { method: "POST" });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contracts() });
+            queryClient.setQueryData(legalQueryKeys.contract(data.id), data);
+        },
+    });
+    const voidContract = useMutation({
+        mutationFn: async (id) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/contracts/${id}/void`, legalContractSingleResponse, { baseUrl, fetcher }, { method: "POST" });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contracts() });
+            queryClient.setQueryData(legalQueryKeys.contract(data.id), data);
+        },
+    });
+    /**
+     * Trigger a fresh document render for a contract. First call issues the
+     * draft + generates via the server's configured generator; subsequent
+     * calls (see `regenerate`) replace the attachment.
+     */
+    const generateDocument = useMutation({
+        mutationFn: async ({ id, input = {}, }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/contracts/${id}/generate-document`, legalContractGenerateDocumentResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (_data, variables) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contract(variables.id) });
+            void queryClient.invalidateQueries({
+                queryKey: legalQueryKeys.contractAttachments(variables.id),
+            });
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contracts() });
+        },
+    });
+    /**
+     * Same as `generateDocument` but explicit about replacing an existing
+     * attachment of the same kind. Use this for the operator's "Regenerate"
+     * button so stale PDFs don't accumulate.
+     */
+    const regenerateDocument = useMutation({
+        mutationFn: async ({ id, input = {}, }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/contracts/${id}/regenerate-document`, legalContractGenerateDocumentResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (_data, variables) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contract(variables.id) });
+            void queryClient.invalidateQueries({
+                queryKey: legalQueryKeys.contractAttachments(variables.id),
+            });
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contracts() });
+        },
+    });
+    const generateForBooking = useMutation({
+        mutationFn: async ({ bookingId, input = {}, }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/contracts/bookings/${bookingId}/generate-document`, legalBookingContractGenerateDocumentResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data, variables) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contracts() });
+            void queryClient.invalidateQueries({
+                queryKey: legalQueryKeys.contractsList({ bookingId: variables.bookingId }),
+            });
+            queryClient.setQueryData(legalQueryKeys.contract(data.contract.id), data.contract);
+            void queryClient.invalidateQueries({
+                queryKey: legalQueryKeys.contractAttachments(data.contract.id),
+            });
+        },
+    });
+    return {
+        create,
+        update,
+        remove,
+        issue,
+        send,
+        execute,
+        voidContract,
+        generateDocument,
+        regenerateDocument,
+        generateForBooking,
+    };
+}

package/dist/hooks/use-contract-signature-mutation.d.ts

@@ -0,0 +1,35 @@
+import type { insertContractSignatureSchema } from "@voyant-travel/legal/contracts/validation";
+import type { z } from "zod";
+export type CreateLegalContractSignatureInput = z.input<typeof insertContractSignatureSchema>;
+export declare function useLegalContractSignatureMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        contractId: string;
+        data: {
+            method: "manual" | "electronic" | "docusign" | "other";
+            signerName: string;
+            id: string;
+            contractId: string;
+            signerEmail: string | null;
+            signerRole: string | null;
+            personId: string | null;
+            provider: string | null;
+            externalReference: string | null;
+            signatureData: string | null;
+            ipAddress: string | null;
+            userAgent: string | null;
+            signedAt: string;
+            createdAt: string;
+            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;
+            metadata?: Record<string, unknown> | null | undefined;
+        };
+    }, Error, {
+        contractId: string;
+        input: CreateLegalContractSignatureInput;
+    }, unknown>;
+};
+//# sourceMappingURL=use-contract-signature-mutation.d.ts.map

package/dist/hooks/use-contract-signature-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-contract-signature-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contract-signature-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,2CAA2C,CAAA;AAC9F,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAO5B,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAE7F,wBAAgB,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAS/B,MAAM;eACX,iCAAiC;;EAmB7C"}

package/dist/hooks/use-contract-signature-mutation.js

@@ -0,0 +1,23 @@
+"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 { legalContractSignatureRecordSchema } from "../schemas.js";
+export function useLegalContractSignatureMutation() {
+    const { baseUrl, fetcher } = useVoyantLegalContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async ({ contractId, input, }) => {
+            const data = await fetchWithValidation(`/v1/admin/legal/contracts/${contractId}/sign`, legalContractSignatureRecordSchema, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return { contractId, data };
+        },
+        onSuccess: ({ contractId }) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.contract(contractId) });
+            void queryClient.invalidateQueries({
+                queryKey: legalQueryKeys.contractSignatures(contractId),
+            });
+        },
+    });
+    return { create };
+}

package/dist/hooks/use-contract-signatures.d.ts

@@ -0,0 +1,28 @@
+export interface UseLegalContractSignaturesOptions {
+    contractId: string;
+    enabled?: boolean;
+}
+export declare function useLegalContractSignatures(options: UseLegalContractSignaturesOptions): import("@tanstack/react-query").UseQueryResult<{
+    method: "manual" | "electronic" | "docusign" | "other";
+    signerName: string;
+    id: string;
+    contractId: string;
+    signerEmail: string | null;
+    signerRole: string | null;
+    personId: string | null;
+    provider: string | null;
+    externalReference: string | null;
+    signatureData: string | null;
+    ipAddress: string | null;
+    userAgent: string | null;
+    signedAt: string;
+    createdAt: string;
+    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;
+    metadata?: Record<string, unknown> | null | undefined;
+}[], Error>;
+//# sourceMappingURL=use-contract-signatures.d.ts.map

package/dist/hooks/use-contract-signatures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-contract-signatures.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contract-signatures.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,iCAAiC;IAChD,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,iCAAiC;;;;;;;;;;;;;;;;;;;;;;YAQpF"}

package/dist/hooks/use-contract-signatures.js

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

package/dist/hooks/use-contract-template-authoring.d.ts

@@ -0,0 +1,5 @@
+export declare function useLegalContractTemplateAuthoring(): {
+    variableCatalog: import("@voyant-travel/legal/contracts").ContractTemplateVariableCategory[];
+    liquidSnippets: import("@voyant-travel/legal/contracts").ContractTemplateLiquidSnippet[];
+};
+//# sourceMappingURL=use-contract-template-authoring.d.ts.map

package/dist/hooks/use-contract-template-authoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-contract-template-authoring.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contract-template-authoring.ts"],"names":[],"mappings":"AAKA,wBAAgB,iCAAiC;;;EAKhD"}

package/dist/hooks/use-contract-template-authoring.js

@@ -0,0 +1,7 @@
+import { contractTemplateLiquidSnippets, contractTemplateVariableCatalog, } from "@voyant-travel/legal/contracts";
+export function useLegalContractTemplateAuthoring() {
+    return {
+        variableCatalog: contractTemplateVariableCatalog,
+        liquidSnippets: contractTemplateLiquidSnippets,
+    };
+}

package/dist/hooks/use-contract-template-mutation.d.ts

@@ -0,0 +1,56 @@
+import type { insertContractTemplateSchema, updateContractTemplateSchema } from "@voyant-travel/legal/contracts/validation";
+import type { z } from "zod";
+export type CreateLegalContractTemplateInput = z.input<typeof insertContractTemplateSchema>;
+export type UpdateLegalContractTemplateInput = z.input<typeof updateContractTemplateSchema>;
+export declare function useLegalContractTemplateMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        name: string;
+        slug: string;
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        language: string;
+        body: string;
+        active: boolean;
+        id: string;
+        description: string | null;
+        isDefault: boolean;
+        createdAt: string;
+        updatedAt: string;
+        channelId?: string | null | undefined;
+        variableSchema?: Record<string, unknown> | null | undefined;
+        currentVersionId?: string | null | undefined;
+    }, Error, {
+        name: string;
+        slug: string;
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        body: string;
+        language?: string | undefined;
+        description?: string | null | undefined;
+        variableSchema?: Record<string, unknown> | null | undefined;
+        channelId?: string | null | undefined;
+        isDefault?: boolean | undefined;
+        active?: boolean | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        name: string;
+        slug: string;
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        language: string;
+        body: string;
+        active: boolean;
+        id: string;
+        description: string | null;
+        isDefault: boolean;
+        createdAt: string;
+        updatedAt: string;
+        channelId?: string | null | undefined;
+        variableSchema?: Record<string, unknown> | null | undefined;
+        currentVersionId?: string | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateLegalContractTemplateInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-contract-template-mutation.d.ts.map

package/dist/hooks/use-contract-template-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-contract-template-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contract-template-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,4BAA4B,EAC5B,4BAA4B,EAC7B,MAAM,2CAA2C,CAAA;AAClD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAO5B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBJ,MAAM;eAAS,gCAAgC;;;;;EA+B1F"}

package/dist/hooks/use-contract-template-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 { legalContractTemplateSingleResponse, successEnvelope } from "../schemas.js";
+export function useLegalContractTemplateMutation() {
+    const { baseUrl, fetcher } = useVoyantLegalContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/admin/legal/contracts/templates", legalContractTemplateSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.templates() });
+            queryClient.setQueryData(legalQueryKeys.template(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/contracts/templates/${id}`, legalContractTemplateSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.templates() });
+            queryClient.setQueryData(legalQueryKeys.template(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/admin/legal/contracts/templates/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.templates() });
+            queryClient.removeQueries({ queryKey: legalQueryKeys.template(id) });
+            queryClient.removeQueries({ queryKey: legalQueryKeys.templateVersions(id) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-contract-template-version-mutation.d.ts

@@ -0,0 +1,22 @@
+import type { insertContractTemplateVersionSchema } from "@voyant-travel/legal/contracts/validation";
+import type { z } from "zod";
+export type CreateLegalContractTemplateVersionInput = z.input<typeof insertContractTemplateVersionSchema>;
+export declare function useLegalContractTemplateVersionMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        templateId: string;
+        data: {
+            body: string;
+            id: string;
+            templateId: string;
+            version: number;
+            changelog: string | null;
+            createdBy: string | null;
+            createdAt: string;
+            variableSchema?: Record<string, unknown> | null | undefined;
+        };
+    }, Error, {
+        templateId: string;
+        input: CreateLegalContractTemplateVersionInput;
+    }, unknown>;
+};
+//# sourceMappingURL=use-contract-template-version-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-contract-template-version-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contract-template-version-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,2CAA2C,CAAA;AACpG,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAO5B,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,mCAAmC,CAC3C,CAAA;AAED,wBAAgB,uCAAuC;;;;;;;;;;;;;;oBASrC,MAAM;eACX,uCAAuC;;EAkBnD"}

package/dist/hooks/use-contract-template-version-mutation.js

@@ -0,0 +1,22 @@
+"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 { legalContractTemplateVersionRecordSchema } from "../schemas.js";
+export function useLegalContractTemplateVersionMutation() {
+    const { baseUrl, fetcher } = useVoyantLegalContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async ({ templateId, input, }) => {
+            const data = await fetchWithValidation(`/v1/admin/legal/contracts/templates/${templateId}/versions`, legalContractTemplateVersionRecordSchema, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return { templateId, data };
+        },
+        onSuccess: ({ templateId }) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.templates() });
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.template(templateId) });
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.templateVersions(templateId) });
+        },
+    });
+    return { create };
+}

package/dist/hooks/use-contract-template-versions.d.ts

@@ -0,0 +1,15 @@
+export interface UseLegalContractTemplateVersionsOptions {
+    templateId: string;
+    enabled?: boolean;
+}
+export declare function useLegalContractTemplateVersions(options: UseLegalContractTemplateVersionsOptions): import("@tanstack/react-query").UseQueryResult<{
+    body: string;
+    id: string;
+    templateId: string;
+    version: number;
+    changelog: string | null;
+    createdBy: string | null;
+    createdAt: string;
+    variableSchema?: Record<string, unknown> | null | undefined;
+}[], Error>;
+//# sourceMappingURL=use-contract-template-versions.d.ts.map

package/dist/hooks/use-contract-template-versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-contract-template-versions.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contract-template-versions.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,uCAAuC;IACtD,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,uCAAuC;;;;;;;;;YAQhG"}

package/dist/hooks/use-contract-template-versions.js

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

package/dist/hooks/use-contract-template.d.ts

@@ -0,0 +1,20 @@
+export interface UseLegalContractTemplateOptions {
+    enabled?: boolean;
+}
+export declare function useLegalContractTemplate(id: string, options?: UseLegalContractTemplateOptions): import("@tanstack/react-query").UseQueryResult<{
+    name: string;
+    slug: string;
+    scope: "other" | "customer" | "supplier" | "partner" | "channel";
+    language: string;
+    body: string;
+    active: boolean;
+    id: string;
+    description: string | null;
+    isDefault: boolean;
+    createdAt: string;
+    updatedAt: string;
+    channelId?: string | null | undefined;
+    variableSchema?: Record<string, unknown> | null | undefined;
+    currentVersionId?: string | null | undefined;
+}, Error>;
+//# sourceMappingURL=use-contract-template.d.ts.map

package/dist/hooks/use-contract-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-contract-template.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contract-template.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,+BAA+B;IAC9C,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,+BAAoC;;;;;;;;;;;;;;;UAS9C"}

package/dist/hooks/use-contract-template.js

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

package/dist/hooks/use-contract-templates.d.ts

@@ -0,0 +1,26 @@
+import type { LegalContractTemplatesListFilters } from "../query-keys.js";
+export interface UseLegalContractTemplatesOptions extends LegalContractTemplatesListFilters {
+    enabled?: boolean;
+}
+export declare function useLegalContractTemplates(options?: UseLegalContractTemplatesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        name: string;
+        slug: string;
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        language: string;
+        body: string;
+        active: boolean;
+        id: string;
+        description: string | null;
+        isDefault: boolean;
+        createdAt: string;
+        updatedAt: string;
+        channelId?: string | null | undefined;
+        variableSchema?: Record<string, unknown> | null | undefined;
+        currentVersionId?: string | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-contract-templates.d.ts.map

package/dist/hooks/use-contract-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-contract-templates.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contract-templates.ts"],"names":[],"mappings":"AAKA,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;;;;;;;;;;;;;;;;;;;;UAQvF"}

package/dist/hooks/use-contract-templates.js

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

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

@@ -0,0 +1,47 @@
+export interface UseLegalContractOptions {
+    enabled?: boolean;
+}
+export declare function useLegalContract(id: string, options?: UseLegalContractOptions): import("@tanstack/react-query").UseQueryResult<{
+    language: string;
+    scope: "other" | "customer" | "supplier" | "partner" | "channel";
+    status: "void" | "draft" | "issued" | "sent" | "signed" | "executed" | "expired";
+    title: string;
+    id: string;
+    contractNumber: string | null;
+    stageHistory: {
+        stage: "void" | "draft" | "issued" | "sent" | "signed" | "executed" | "expired";
+        previousStage: "void" | "draft" | "issued" | "sent" | "signed" | "executed" | "expired" | null;
+        transition: "issued" | "sent" | "signed" | "executed" | "created" | "voided";
+        enteredAt: string;
+        actorId?: string | null | undefined;
+    }[];
+    templateVersionId: string | null;
+    seriesId: string | null;
+    personId: string | null;
+    organizationId: string | null;
+    supplierId: string | null;
+    channelId: string | null;
+    bookingId: string | null;
+    renderedBodyFormat: "markdown" | "html" | "lexical_json";
+    renderedBody: string | null;
+    createdAt: string;
+    updatedAt: string;
+    variables?: Record<string, unknown> | null | undefined;
+    metadata?: Record<string, unknown> | 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;
+    personFirstName?: string | null | undefined;
+    personLastName?: string | null | undefined;
+    personEmail?: string | null | undefined;
+    personPhone?: string | null | undefined;
+    issuedAt?: string | null | undefined;
+    sentAt?: string | null | undefined;
+    executedAt?: string | null | undefined;
+    expiresAt?: string | null | undefined;
+    voidedAt?: string | null | undefined;
+}, Error>;
+//# sourceMappingURL=use-contract.d.ts.map

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

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

package/dist/hooks/use-contract.js

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