@voyantjs/legal-react 0.2.0

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+export type VoyantFetcher = (url: string, init?: RequestInit) => Promise<Response>;
+export declare const defaultFetcher: VoyantFetcher;
+export declare class VoyantApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+export interface FetchWithValidationOptions {
+    baseUrl: string;
+    fetcher: VoyantFetcher;
+}
+export declare function fetchWithValidation<TOut>(path: string, schema: z.ZodType<TOut>, options: FetchWithValidationOptions, init?: RequestInit): Promise<TOut>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;AAElF,eAAO,MAAM,cAAc,EAAE,aACoB,CAAA;AAEjD,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;gBAEV,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;CAM3D;AAaD,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,aAAa,CAAA;CACvB;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAC5C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EACvB,OAAO,EAAE,0BAA0B,EACnC,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,IAAI,CAAC,CA8Bf"}

package/dist/client.js

@@ -0,0 +1,58 @@
+export const defaultFetcher = (url, init) => fetch(url, { credentials: "include", ...init });
+export class VoyantApiError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.name = "VoyantApiError";
+        this.status = status;
+        this.body = body;
+    }
+}
+function extractErrorMessage(status, statusText, body) {
+    if (typeof body === "object" && body !== null && "error" in body) {
+        const err = body.error;
+        if (typeof err === "string")
+            return err;
+        if (typeof err === "object" && err !== null && "message" in err) {
+            return String(err.message);
+        }
+    }
+    return `Voyant API error: ${status} ${statusText}`;
+}
+export async function fetchWithValidation(path, schema, options, init) {
+    const url = joinUrl(options.baseUrl, path);
+    const headers = new Headers(init?.headers);
+    if (init?.body !== undefined && !headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+    }
+    const response = await options.fetcher(url, { ...init, headers });
+    if (!response.ok) {
+        const body = await safeJson(response);
+        throw new VoyantApiError(extractErrorMessage(response.status, response.statusText, body), response.status, body);
+    }
+    if (response.status === 204)
+        return schema.parse(undefined);
+    const body = await safeJson(response);
+    const parsed = schema.safeParse(body);
+    if (!parsed.success) {
+        throw new VoyantApiError(`Voyant API response failed validation: ${parsed.error.message}`, response.status, body);
+    }
+    return parsed.data;
+}
+async function safeJson(response) {
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function joinUrl(baseUrl, path) {
+    const trimmedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const trimmedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${trimmedBase}${trimmedPath}`;
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,25 @@
+export * from "./use-contract.js";
+export * from "./use-contract-attachment-mutation.js";
+export * from "./use-contract-attachments.js";
+export * from "./use-contract-mutation.js";
+export * from "./use-contract-signature-mutation.js";
+export * from "./use-contract-signatures.js";
+export * from "./use-contract-template.js";
+export * from "./use-contract-template-mutation.js";
+export * from "./use-contract-template-version-mutation.js";
+export * from "./use-contract-template-versions.js";
+export * from "./use-contract-templates.js";
+export * from "./use-contracts.js";
+export * from "./use-number-series.js";
+export * from "./use-number-series-mutation.js";
+export * from "./use-policies.js";
+export * from "./use-policy.js";
+export * from "./use-policy-acceptances.js";
+export * from "./use-policy-assignment-mutation.js";
+export * from "./use-policy-assignments.js";
+export * from "./use-policy-mutation.js";
+export * from "./use-policy-rule-mutation.js";
+export * from "./use-policy-rules.js";
+export * from "./use-policy-version-mutation.js";
+export * from "./use-policy-versions.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,uCAAuC,CAAA;AACrD,cAAc,+BAA+B,CAAA;AAC7C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,sCAAsC,CAAA;AACpD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qCAAqC,CAAA;AACnD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,qCAAqC,CAAA;AACnD,cAAc,6BAA6B,CAAA;AAC3C,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA;AACtC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,6BAA6B,CAAA;AAC3C,cAAc,qCAAqC,CAAA;AACnD,cAAc,6BAA6B,CAAA;AAC3C,cAAc,0BAA0B,CAAA;AACxC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,uBAAuB,CAAA;AACrC,cAAc,kCAAkC,CAAA;AAChD,cAAc,0BAA0B,CAAA"}

package/dist/hooks/index.js

@@ -0,0 +1,24 @@
+export * from "./use-contract.js";
+export * from "./use-contract-attachment-mutation.js";
+export * from "./use-contract-attachments.js";
+export * from "./use-contract-mutation.js";
+export * from "./use-contract-signature-mutation.js";
+export * from "./use-contract-signatures.js";
+export * from "./use-contract-template.js";
+export * from "./use-contract-template-mutation.js";
+export * from "./use-contract-template-version-mutation.js";
+export * from "./use-contract-template-versions.js";
+export * from "./use-contract-templates.js";
+export * from "./use-contracts.js";
+export * from "./use-number-series.js";
+export * from "./use-number-series-mutation.js";
+export * from "./use-policies.js";
+export * from "./use-policy.js";
+export * from "./use-policy-acceptances.js";
+export * from "./use-policy-assignment-mutation.js";
+export * from "./use-policy-assignments.js";
+export * from "./use-policy-mutation.js";
+export * from "./use-policy-rule-mutation.js";
+export * from "./use-policy-rules.js";
+export * from "./use-policy-version-mutation.js";
+export * from "./use-policy-versions.js";

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

@@ -0,0 +1,53 @@
+import type { insertContractAttachmentSchema, updateContractAttachmentSchema } from "@voyantjs/legal/contracts/validation";
+import type { z } from "zod";
+export type CreateLegalContractAttachmentInput = z.input<typeof insertContractAttachmentSchema>;
+export type UpdateLegalContractAttachmentInput = z.input<typeof updateContractAttachmentSchema>;
+export declare function useLegalContractAttachmentMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        contractId: string;
+        data: {
+            kind: string;
+            name: string;
+            id: string;
+            contractId: string;
+            mimeType: string | null;
+            fileSize: number | null;
+            storageKey: string | null;
+            checksum: string | null;
+            createdAt: string;
+            metadata?: Record<string, unknown> | null | undefined;
+        };
+    }, Error, {
+        contractId: string;
+        input: CreateLegalContractAttachmentInput;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        contractId: string;
+        data: {
+            kind: string;
+            name: string;
+            id: string;
+            contractId: string;
+            mimeType: string | null;
+            fileSize: number | null;
+            storageKey: string | null;
+            checksum: string | null;
+            createdAt: string;
+            metadata?: Record<string, unknown> | null | undefined;
+        };
+    }, Error, {
+        contractId: string;
+        id: string;
+        input: UpdateLegalContractAttachmentInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        contractId: string;
+        data: {
+            success: boolean;
+        };
+    }, Error, {
+        contractId: string;
+        id: string;
+    }, unknown>;
+};
+//# sourceMappingURL=use-contract-attachment-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-contract-attachment-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contract-attachment-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,8BAA8B,EAC9B,8BAA8B,EAC/B,MAAM,sCAAsC,CAAA;AAC7C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAO5B,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE/F,wBAAgB,kCAAkC;;;;;;;;;;;;;;;;oBAShC,MAAM;eACX,kCAAkC;;;;;;;;;;;;;;;;;oBAuB7B,MAAM;YACd,MAAM;eACH,kCAAkC;;;;;;;;oBAkBU,MAAM;YAAM,MAAM;;EAe1E"}

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

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

@@ -0,0 +1,17 @@
+export interface UseLegalContractAttachmentsOptions {
+    contractId: string;
+    enabled?: boolean;
+}
+export declare function useLegalContractAttachments(options: UseLegalContractAttachmentsOptions): import("@tanstack/react-query").UseQueryResult<{
+    kind: string;
+    name: string;
+    id: string;
+    contractId: string;
+    mimeType: string | null;
+    fileSize: number | null;
+    storageKey: string | null;
+    checksum: string | null;
+    createdAt: string;
+    metadata?: Record<string, unknown> | null | undefined;
+}[], Error>;
+//# sourceMappingURL=use-contract-attachments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-contract-attachments.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contract-attachments.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,kCAAkC;IACjD,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,kCAAkC;;;;;;;;;;;YAQtF"}

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

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

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

@@ -0,0 +1,191 @@
+import type { insertContractSchema, updateContractSchema } from "@voyantjs/legal/contracts/validation";
+import type { z } from "zod";
+export type CreateLegalContractInput = z.input<typeof insertContractSchema>;
+export type UpdateLegalContractInput = z.input<typeof updateContractSchema>;
+export declare function useLegalContractMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        status: "void" | "draft" | "issued" | "sent" | "signed" | "executed" | "expired";
+        title: string;
+        language: string;
+        id: string;
+        contractNumber: string | null;
+        templateVersionId: string | null;
+        seriesId: string | null;
+        personId: string | null;
+        organizationId: string | null;
+        supplierId: string | null;
+        channelId: string | null;
+        bookingId: string | null;
+        orderId: 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;
+        issuedAt?: string | null | undefined;
+        sentAt?: string | null | undefined;
+        executedAt?: string | null | undefined;
+        expiresAt?: string | null | undefined;
+        voidedAt?: string | null | undefined;
+    }, Error, {
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        title: string;
+        status?: "void" | "draft" | "issued" | "sent" | "signed" | "executed" | "expired" | undefined;
+        templateVersionId?: string | null | undefined;
+        seriesId?: string | null | undefined;
+        personId?: string | null | undefined;
+        organizationId?: string | null | undefined;
+        supplierId?: string | null | undefined;
+        channelId?: string | null | undefined;
+        bookingId?: string | null | undefined;
+        orderId?: string | null | undefined;
+        expiresAt?: string | null | undefined;
+        language?: string | undefined;
+        variables?: Record<string, unknown> | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        status: "void" | "draft" | "issued" | "sent" | "signed" | "executed" | "expired";
+        title: string;
+        language: string;
+        id: string;
+        contractNumber: string | null;
+        templateVersionId: string | null;
+        seriesId: string | null;
+        personId: string | null;
+        organizationId: string | null;
+        supplierId: string | null;
+        channelId: string | null;
+        bookingId: string | null;
+        orderId: 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;
+        issuedAt?: string | null | undefined;
+        sentAt?: string | null | undefined;
+        executedAt?: string | null | undefined;
+        expiresAt?: string | null | undefined;
+        voidedAt?: string | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateLegalContractInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+    issue: import("@tanstack/react-query").UseMutationResult<{
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        status: "void" | "draft" | "issued" | "sent" | "signed" | "executed" | "expired";
+        title: string;
+        language: string;
+        id: string;
+        contractNumber: string | null;
+        templateVersionId: string | null;
+        seriesId: string | null;
+        personId: string | null;
+        organizationId: string | null;
+        supplierId: string | null;
+        channelId: string | null;
+        bookingId: string | null;
+        orderId: 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;
+        issuedAt?: string | null | undefined;
+        sentAt?: string | null | undefined;
+        executedAt?: string | null | undefined;
+        expiresAt?: string | null | undefined;
+        voidedAt?: string | null | undefined;
+    }, Error, string, unknown>;
+    send: import("@tanstack/react-query").UseMutationResult<{
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        status: "void" | "draft" | "issued" | "sent" | "signed" | "executed" | "expired";
+        title: string;
+        language: string;
+        id: string;
+        contractNumber: string | null;
+        templateVersionId: string | null;
+        seriesId: string | null;
+        personId: string | null;
+        organizationId: string | null;
+        supplierId: string | null;
+        channelId: string | null;
+        bookingId: string | null;
+        orderId: 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;
+        issuedAt?: string | null | undefined;
+        sentAt?: string | null | undefined;
+        executedAt?: string | null | undefined;
+        expiresAt?: string | null | undefined;
+        voidedAt?: string | null | undefined;
+    }, Error, string, unknown>;
+    execute: import("@tanstack/react-query").UseMutationResult<{
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        status: "void" | "draft" | "issued" | "sent" | "signed" | "executed" | "expired";
+        title: string;
+        language: string;
+        id: string;
+        contractNumber: string | null;
+        templateVersionId: string | null;
+        seriesId: string | null;
+        personId: string | null;
+        organizationId: string | null;
+        supplierId: string | null;
+        channelId: string | null;
+        bookingId: string | null;
+        orderId: 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;
+        issuedAt?: string | null | undefined;
+        sentAt?: string | null | undefined;
+        executedAt?: string | null | undefined;
+        expiresAt?: string | null | undefined;
+        voidedAt?: string | null | undefined;
+    }, Error, string, unknown>;
+    voidContract: import("@tanstack/react-query").UseMutationResult<{
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        status: "void" | "draft" | "issued" | "sent" | "signed" | "executed" | "expired";
+        title: string;
+        language: string;
+        id: string;
+        contractNumber: string | null;
+        templateVersionId: string | null;
+        seriesId: string | null;
+        personId: string | null;
+        organizationId: string | null;
+        supplierId: string | null;
+        channelId: string | null;
+        bookingId: string | null;
+        orderId: 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;
+        issuedAt?: string | null | undefined;
+        sentAt?: string | null | undefined;
+        executedAt?: string | null | undefined;
+        expiresAt?: string | null | undefined;
+        voidedAt?: string | null | undefined;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-contract-mutation.d.ts.map

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,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,sCAAsC,CAAA;AAC7C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAO5B,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;AAE3E,wBAAgB,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBI,MAAM;eAAS,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkGlF"}

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

@@ -0,0 +1,82 @@
+"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 { 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 (id) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/contracts/${id}/send`, legalContractSingleResponse, { baseUrl, fetcher }, { method: "POST" });
+            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);
+        },
+    });
+    return { create, update, remove, issue, send, execute, voidContract };
+}

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

@@ -0,0 +1,29 @@
+import type { insertContractSignatureSchema } from "@voyantjs/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: {
+            signerName: string;
+            method: "manual" | "electronic" | "docusign" | "other";
+            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;
+            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,sCAAsC,CAAA;AACzF,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,22 @@
+export interface UseLegalContractSignaturesOptions {
+    contractId: string;
+    enabled?: boolean;
+}
+export declare function useLegalContractSignatures(options: UseLegalContractSignaturesOptions): import("@tanstack/react-query").UseQueryResult<{
+    signerName: string;
+    method: "manual" | "electronic" | "docusign" | "other";
+    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;
+    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,
+    });
+}