@voyantjs/legal-react 0.2.0

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

@@ -0,0 +1,53 @@
+import type { insertContractTemplateSchema, updateContractTemplateSchema } from "@voyantjs/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;
+        bodyFormat: "markdown" | "html" | "lexical_json";
+        body: string;
+        active: boolean;
+        id: string;
+        description: string | null;
+        createdAt: string;
+        updatedAt: string;
+        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;
+        bodyFormat?: "markdown" | "html" | "lexical_json" | undefined;
+        variableSchema?: Record<string, unknown> | null | undefined;
+        active?: boolean | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        name: string;
+        slug: string;
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        language: string;
+        bodyFormat: "markdown" | "html" | "lexical_json";
+        body: string;
+        active: boolean;
+        id: string;
+        description: string | null;
+        createdAt: string;
+        updatedAt: string;
+        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,sCAAsC,CAAA;AAC7C,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,23 @@
+import type { insertContractTemplateVersionSchema } from "@voyantjs/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: {
+            bodyFormat: "markdown" | "html" | "lexical_json";
+            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,sCAAsC,CAAA;AAC/F,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,16 @@
+export interface UseLegalContractTemplateVersionsOptions {
+    templateId: string;
+    enabled?: boolean;
+}
+export declare function useLegalContractTemplateVersions(options: UseLegalContractTemplateVersionsOptions): import("@tanstack/react-query").UseQueryResult<{
+    bodyFormat: "markdown" | "html" | "lexical_json";
+    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,19 @@
+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;
+    bodyFormat: "markdown" | "html" | "lexical_json";
+    body: string;
+    active: boolean;
+    id: string;
+    description: string | null;
+    createdAt: string;
+    updatedAt: string;
+    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,25 @@
+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;
+        bodyFormat: "markdown" | "html" | "lexical_json";
+        body: string;
+        active: boolean;
+        id: string;
+        description: string | null;
+        createdAt: string;
+        updatedAt: string;
+        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,31 @@
+export interface UseLegalContractOptions {
+    enabled?: boolean;
+}
+export declare function useLegalContract(id: string, options?: UseLegalContractOptions): import("@tanstack/react-query").UseQueryResult<{
+    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>;
+//# 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,
+    });
+}

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

@@ -0,0 +1,37 @@
+import type { LegalContractsListFilters } from "../query-keys.js";
+export interface UseLegalContractsOptions extends LegalContractsListFilters {
+    enabled?: boolean;
+}
+export declare function useLegalContracts(options?: UseLegalContractsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        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;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-contracts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-contracts.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contracts.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAA;AAGjE,MAAM,WAAW,wBAAyB,SAAQ,yBAAyB;IACzE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAQvE"}

package/dist/hooks/use-contracts.js

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

package/dist/hooks/use-number-series-mutation.d.ts

@@ -0,0 +1,52 @@
+import type { insertContractNumberSeriesSchema, updateContractNumberSeriesSchema } from "@voyantjs/legal/contracts/validation";
+import type { z } from "zod";
+export type CreateLegalContractNumberSeriesInput = z.input<typeof insertContractNumberSeriesSchema>;
+export type UpdateLegalContractNumberSeriesInput = z.input<typeof updateContractNumberSeriesSchema>;
+export declare function useLegalContractNumberSeriesMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        code: string;
+        name: string;
+        prefix: string;
+        separator: string;
+        padLength: number;
+        resetStrategy: "never" | "annual" | "monthly";
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        active: boolean;
+        id: string;
+        currentSequence: number;
+        createdAt: string;
+        updatedAt: string;
+        resetAt?: string | null | undefined;
+    }, Error, {
+        code: string;
+        name: string;
+        prefix?: string | undefined;
+        separator?: string | undefined;
+        padLength?: number | undefined;
+        resetStrategy?: "never" | "annual" | "monthly" | undefined;
+        scope?: "other" | "customer" | "supplier" | "partner" | "channel" | undefined;
+        active?: boolean | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        code: string;
+        name: string;
+        prefix: string;
+        separator: string;
+        padLength: number;
+        resetStrategy: "never" | "annual" | "monthly";
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        active: boolean;
+        id: string;
+        currentSequence: number;
+        createdAt: string;
+        updatedAt: string;
+        resetAt?: string | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateLegalContractNumberSeriesInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-number-series-mutation.d.ts.map

package/dist/hooks/use-number-series-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-number-series-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-number-series-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,gCAAgC,EAChC,gCAAgC,EACjC,MAAM,sCAAsC,CAAA;AAC7C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAM5B,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AACnG,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAEnG,wBAAgB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAyB1C,MAAM;eACH,oCAAoC;;;;;EA+BhD"}

package/dist/hooks/use-number-series-mutation.js

@@ -0,0 +1,38 @@
+"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 { legalContractNumberSeriesSingleResponse, successEnvelope } from "../schemas.js";
+export function useLegalContractNumberSeriesMutation() {
+    const { baseUrl, fetcher } = useVoyantLegalContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/admin/legal/contracts/number-series", legalContractNumberSeriesSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.numberSeries() });
+            queryClient.setQueryData(legalQueryKeys.numberSeriesDetail(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input, }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/legal/contracts/number-series/${id}`, legalContractNumberSeriesSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.numberSeries() });
+            queryClient.setQueryData(legalQueryKeys.numberSeriesDetail(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => fetchWithValidation(`/v1/admin/legal/contracts/number-series/${id}`, successEnvelope, { baseUrl, fetcher }, { method: "DELETE" }),
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: legalQueryKeys.numberSeries() });
+            queryClient.removeQueries({ queryKey: legalQueryKeys.numberSeriesDetail(id) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-number-series.d.ts

@@ -0,0 +1,25 @@
+import type { LegalContractNumberSeriesListFilters } from "../query-keys.js";
+export interface UseLegalContractNumberSeriesOptions extends LegalContractNumberSeriesListFilters {
+    enabled?: boolean;
+}
+export declare function useLegalContractNumberSeries(options?: UseLegalContractNumberSeriesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        code: string;
+        name: string;
+        prefix: string;
+        separator: string;
+        padLength: number;
+        resetStrategy: "never" | "annual" | "monthly";
+        scope: "other" | "customer" | "supplier" | "partner" | "channel";
+        active: boolean;
+        id: string;
+        currentSequence: number;
+        createdAt: string;
+        updatedAt: string;
+        resetAt?: string | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-number-series.d.ts.map

package/dist/hooks/use-number-series.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-number-series.d.ts","sourceRoot":"","sources":["../../src/hooks/use-number-series.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,kBAAkB,CAAA;AAG5E,MAAM,WAAW,mCAAoC,SAAQ,oCAAoC;IAC/F,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,4BAA4B,CAAC,OAAO,GAAE,mCAAwC;;;;;;;;;;;;;;;;;;;UAO7F"}

package/dist/hooks/use-number-series.js

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

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

@@ -0,0 +1,22 @@
+import type { LegalPoliciesListFilters } from "../query-keys.js";
+export interface UseLegalPoliciesOptions extends LegalPoliciesListFilters {
+    enabled?: boolean;
+}
+export declare function useLegalPolicies(options?: UseLegalPoliciesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        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;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-policies.d.ts.map

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

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

package/dist/hooks/use-policies.js

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

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

@@ -0,0 +1,22 @@
+import type { LegalPolicyAcceptancesListFilters } from "../query-keys.js";
+export interface UseLegalPolicyAcceptancesOptions extends LegalPolicyAcceptancesListFilters {
+    enabled?: boolean;
+}
+export declare function useLegalPolicyAcceptances(options?: UseLegalPolicyAcceptancesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        policyVersionId: string;
+        personId: string | null;
+        bookingId: string | null;
+        acceptedAt: string;
+        method: "implicit" | "explicit_checkbox" | "signature";
+        createdAt: string;
+        orderId?: string | null | undefined;
+        offerId?: string | null | undefined;
+        acceptedBy?: string | null | undefined;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+}, Error>;
+//# sourceMappingURL=use-policy-acceptances.d.ts.map

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

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

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