@voyantjs/sellability-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,4 @@
+export * from "./use-sellability-policies.js";
+export * from "./use-sellability-policy.js";
+export * from "./use-sellability-policy-mutation.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,+BAA+B,CAAA;AAC7C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,sCAAsC,CAAA"}

package/dist/hooks/index.js

@@ -0,0 +1,3 @@
+export * from "./use-sellability-policies.js";
+export * from "./use-sellability-policy.js";
+export * from "./use-sellability-policy-mutation.js";

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

@@ -0,0 +1,28 @@
+import type { SellabilityPoliciesListFilters } from "../query-keys.js";
+export interface UseSellabilityPoliciesOptions extends SellabilityPoliciesListFilters {
+    enabled?: boolean;
+}
+export declare function useSellabilityPolicies(options?: UseSellabilityPoliciesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        name: string;
+        priority: number;
+        active: boolean;
+        id: string;
+        scope: "global" | "product" | "option" | "market" | "channel";
+        policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+        productId: string | null;
+        optionId: string | null;
+        marketId: string | null;
+        channelId: string | null;
+        conditions: Record<string, unknown>;
+        effects: Record<string, unknown>;
+        createdAt: string;
+        updatedAt: string;
+        notes?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-sellability-policies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-sellability-policies.d.ts","sourceRoot":"","sources":["../../src/hooks/use-sellability-policies.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,kBAAkB,CAAA;AAGtE,MAAM,WAAW,6BAA8B,SAAQ,8BAA8B;IACnF,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,6BAAkC;;;;;;;;;;;;;;;;;;;;;;UAQjF"}

package/dist/hooks/use-sellability-policies.js

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

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

@@ -0,0 +1,63 @@
+import type { insertSellabilityPolicySchema, updateSellabilityPolicySchema } from "@voyantjs/sellability/validation";
+import type { z } from "zod";
+export type CreateSellabilityPolicyInput = z.input<typeof insertSellabilityPolicySchema>;
+export type UpdateSellabilityPolicyInput = z.input<typeof updateSellabilityPolicySchema>;
+export declare function useSellabilityPolicyMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        name: string;
+        priority: number;
+        active: boolean;
+        id: string;
+        scope: "global" | "product" | "option" | "market" | "channel";
+        policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+        productId: string | null;
+        optionId: string | null;
+        marketId: string | null;
+        channelId: string | null;
+        conditions: Record<string, unknown>;
+        effects: Record<string, unknown>;
+        createdAt: string;
+        updatedAt: string;
+        notes?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        name: string;
+        scope?: "global" | "product" | "option" | "market" | "channel" | undefined;
+        policyType?: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency" | undefined;
+        productId?: string | null | undefined;
+        optionId?: string | null | undefined;
+        marketId?: string | null | undefined;
+        channelId?: string | null | undefined;
+        priority?: number | undefined;
+        active?: boolean | undefined;
+        conditions?: Record<string, unknown> | undefined;
+        effects?: Record<string, unknown> | undefined;
+        notes?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        name: string;
+        priority: number;
+        active: boolean;
+        id: string;
+        scope: "global" | "product" | "option" | "market" | "channel";
+        policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+        productId: string | null;
+        optionId: string | null;
+        marketId: string | null;
+        channelId: string | null;
+        conditions: Record<string, unknown>;
+        effects: Record<string, unknown>;
+        createdAt: string;
+        updatedAt: string;
+        notes?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, Error, {
+        id: string;
+        input: UpdateSellabilityPolicyInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-sellability-policy-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-sellability-policy-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-sellability-policy-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,6BAA6B,EAC7B,6BAA6B,EAC9B,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAO5B,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AACxF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAExF,wBAAgB,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBA,MAAM;eAAS,4BAA4B;;;;;EAgCtF"}

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

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

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

@@ -0,0 +1,22 @@
+export interface UseSellabilityPolicyOptions {
+    enabled?: boolean;
+}
+export declare function useSellabilityPolicy(id: string | null | undefined, options?: UseSellabilityPolicyOptions): import("@tanstack/react-query").UseQueryResult<{
+    name: string;
+    priority: number;
+    active: boolean;
+    id: string;
+    scope: "global" | "product" | "option" | "market" | "channel";
+    policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+    productId: string | null;
+    optionId: string | null;
+    marketId: string | null;
+    channelId: string | null;
+    conditions: Record<string, unknown>;
+    effects: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    notes?: string | null | undefined;
+    metadata?: Record<string, unknown> | null | undefined;
+}, Error>;
+//# sourceMappingURL=use-sellability-policy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-sellability-policy.d.ts","sourceRoot":"","sources":["../../src/hooks/use-sellability-policy.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,2BAA2B;IAC1C,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7B,OAAO,GAAE,2BAAgC;;;;;;;;;;;;;;;;;UAS1C"}

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

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantSellabilityContext } from "../provider.js";
+import { getSellabilityPolicyQueryOptions } from "../query-options.js";
+export function useSellabilityPolicy(id, options = {}) {
+    const { baseUrl, fetcher } = useVoyantSellabilityContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getSellabilityPolicyQueryOptions({ baseUrl, fetcher }, id ?? "__missing__"),
+        enabled: enabled && Boolean(id),
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { defaultFetcher, fetchWithValidation, VoyantApiError, type VoyantFetcher, } from "./client.js";
+export * from "./hooks/index.js";
+export { useVoyantSellabilityContext, type VoyantSellabilityContextValue, VoyantSellabilityProvider, type VoyantSellabilityProviderProps, } from "./provider.js";
+export { type SellabilityPoliciesListFilters, sellabilityQueryKeys, } from "./query-keys.js";
+export { getSellabilityPoliciesQueryOptions, getSellabilityPolicyQueryOptions, } from "./query-options.js";
+export * from "./schemas.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,KAAK,aAAa,GACnB,MAAM,aAAa,CAAA;AACpB,cAAc,kBAAkB,CAAA;AAChC,OAAO,EACL,2BAA2B,EAC3B,KAAK,6BAA6B,EAClC,yBAAyB,EACzB,KAAK,8BAA8B,GACpC,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,KAAK,8BAA8B,EACnC,oBAAoB,GACrB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,kCAAkC,EAClC,gCAAgC,GACjC,MAAM,oBAAoB,CAAA;AAC3B,cAAc,cAAc,CAAA"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { defaultFetcher, fetchWithValidation, VoyantApiError, } from "./client.js";
+export * from "./hooks/index.js";
+export { useVoyantSellabilityContext, VoyantSellabilityProvider, } from "./provider.js";
+export { sellabilityQueryKeys, } from "./query-keys.js";
+export { getSellabilityPoliciesQueryOptions, getSellabilityPolicyQueryOptions, } from "./query-options.js";
+export * from "./schemas.js";

package/dist/provider.d.ts

@@ -0,0 +1,2 @@
+export { useVoyantReactContext as useVoyantSellabilityContext, type VoyantReactContextValue as VoyantSellabilityContextValue, VoyantReactProvider as VoyantSellabilityProvider, type VoyantReactProviderProps as VoyantSellabilityProviderProps, } from "@voyantjs/react";
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,IAAI,2BAA2B,EACpD,KAAK,uBAAuB,IAAI,6BAA6B,EAC7D,mBAAmB,IAAI,yBAAyB,EAChD,KAAK,wBAAwB,IAAI,8BAA8B,GAChE,MAAM,iBAAiB,CAAA"}

package/dist/provider.js

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

package/dist/query-keys.d.ts

@@ -0,0 +1,20 @@
+import type { sellabilityPolicyScopeSchema, sellabilityPolicyTypeSchema } from "@voyantjs/sellability/validation";
+import type { z } from "zod";
+export interface SellabilityPoliciesListFilters {
+    scope?: z.infer<typeof sellabilityPolicyScopeSchema> | undefined;
+    policyType?: z.infer<typeof sellabilityPolicyTypeSchema> | undefined;
+    productId?: string | undefined;
+    optionId?: string | undefined;
+    marketId?: string | undefined;
+    channelId?: string | undefined;
+    active?: boolean | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}
+export declare const sellabilityQueryKeys: {
+    readonly all: readonly ["voyant", "sellability"];
+    readonly policies: () => readonly ["voyant", "sellability", "policies"];
+    readonly policiesList: (filters: SellabilityPoliciesListFilters) => readonly ["voyant", "sellability", "policies", "list", SellabilityPoliciesListFilters];
+    readonly policy: (id: string) => readonly ["voyant", "sellability", "policies", "detail", string];
+};
+//# sourceMappingURL=query-keys.d.ts.map

package/dist/query-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-keys.d.ts","sourceRoot":"","sources":["../src/query-keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,2BAA2B,EAC5B,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,MAAM,WAAW,8BAA8B;IAC7C,KAAK,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,GAAG,SAAS,CAAA;IAChE,UAAU,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,GAAG,SAAS,CAAA;IACpE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC5B;AAED,eAAO,MAAM,oBAAoB;;;qCAIP,8BAA8B;0BAEzC,MAAM;CACX,CAAA"}

package/dist/query-keys.js

@@ -0,0 +1,6 @@
+export const sellabilityQueryKeys = {
+    all: ["voyant", "sellability"],
+    policies: () => [...sellabilityQueryKeys.all, "policies"],
+    policiesList: (filters) => [...sellabilityQueryKeys.policies(), "list", filters],
+    policy: (id) => [...sellabilityQueryKeys.policies(), "detail", id],
+};

package/dist/query-options.d.ts

@@ -0,0 +1,175 @@
+import { type FetchWithValidationOptions } from "./client.js";
+import type { UseSellabilityPoliciesOptions } from "./hooks/use-sellability-policies.js";
+export declare function getSellabilityPoliciesQueryOptions(client: FetchWithValidationOptions, options?: UseSellabilityPoliciesOptions): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    data: {
+        name: string;
+        priority: number;
+        active: boolean;
+        id: string;
+        scope: "global" | "product" | "option" | "market" | "channel";
+        policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+        productId: string | null;
+        optionId: string | null;
+        marketId: string | null;
+        channelId: string | null;
+        conditions: Record<string, unknown>;
+        effects: Record<string, unknown>;
+        createdAt: string;
+        updatedAt: string;
+        notes?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error, {
+    data: {
+        name: string;
+        priority: number;
+        active: boolean;
+        id: string;
+        scope: "global" | "product" | "option" | "market" | "channel";
+        policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+        productId: string | null;
+        optionId: string | null;
+        marketId: string | null;
+        channelId: string | null;
+        conditions: Record<string, unknown>;
+        effects: Record<string, unknown>;
+        createdAt: string;
+        updatedAt: string;
+        notes?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, readonly ["voyant", "sellability", "policies", "list", import("./query-keys.js").SellabilityPoliciesListFilters]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        data: {
+            name: string;
+            priority: number;
+            active: boolean;
+            id: string;
+            scope: "global" | "product" | "option" | "market" | "channel";
+            policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+            productId: string | null;
+            optionId: string | null;
+            marketId: string | null;
+            channelId: string | null;
+            conditions: Record<string, unknown>;
+            effects: Record<string, unknown>;
+            createdAt: string;
+            updatedAt: string;
+            notes?: string | null | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }, readonly ["voyant", "sellability", "policies", "list", import("./query-keys.js").SellabilityPoliciesListFilters], never> | undefined;
+} & {
+    queryKey: readonly ["voyant", "sellability", "policies", "list", import("./query-keys.js").SellabilityPoliciesListFilters] & {
+        [dataTagSymbol]: {
+            data: {
+                name: string;
+                priority: number;
+                active: boolean;
+                id: string;
+                scope: "global" | "product" | "option" | "market" | "channel";
+                policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+                productId: string | null;
+                optionId: string | null;
+                marketId: string | null;
+                channelId: string | null;
+                conditions: Record<string, unknown>;
+                effects: Record<string, unknown>;
+                createdAt: string;
+                updatedAt: string;
+                notes?: string | null | undefined;
+                metadata?: Record<string, unknown> | null | undefined;
+            }[];
+            total: number;
+            limit: number;
+            offset: number;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function getSellabilityPolicyQueryOptions(client: FetchWithValidationOptions, id: string): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    name: string;
+    priority: number;
+    active: boolean;
+    id: string;
+    scope: "global" | "product" | "option" | "market" | "channel";
+    policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+    productId: string | null;
+    optionId: string | null;
+    marketId: string | null;
+    channelId: string | null;
+    conditions: Record<string, unknown>;
+    effects: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    notes?: string | null | undefined;
+    metadata?: Record<string, unknown> | null | undefined;
+}, Error, {
+    name: string;
+    priority: number;
+    active: boolean;
+    id: string;
+    scope: "global" | "product" | "option" | "market" | "channel";
+    policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+    productId: string | null;
+    optionId: string | null;
+    marketId: string | null;
+    channelId: string | null;
+    conditions: Record<string, unknown>;
+    effects: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    notes?: string | null | undefined;
+    metadata?: Record<string, unknown> | null | undefined;
+}, readonly ["voyant", "sellability", "policies", "detail", string]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        name: string;
+        priority: number;
+        active: boolean;
+        id: string;
+        scope: "global" | "product" | "option" | "market" | "channel";
+        policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+        productId: string | null;
+        optionId: string | null;
+        marketId: string | null;
+        channelId: string | null;
+        conditions: Record<string, unknown>;
+        effects: Record<string, unknown>;
+        createdAt: string;
+        updatedAt: string;
+        notes?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, readonly ["voyant", "sellability", "policies", "detail", string], never> | undefined;
+} & {
+    queryKey: readonly ["voyant", "sellability", "policies", "detail", string] & {
+        [dataTagSymbol]: {
+            name: string;
+            priority: number;
+            active: boolean;
+            id: string;
+            scope: "global" | "product" | "option" | "market" | "channel";
+            policyType: "custom" | "capability" | "occupancy" | "pickup" | "question" | "allotment" | "availability_window" | "currency";
+            productId: string | null;
+            optionId: string | null;
+            marketId: string | null;
+            channelId: string | null;
+            conditions: Record<string, unknown>;
+            effects: Record<string, unknown>;
+            createdAt: string;
+            updatedAt: string;
+            notes?: string | null | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+//# sourceMappingURL=query-options.d.ts.map

package/dist/query-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-options.d.ts","sourceRoot":"","sources":["../src/query-options.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,0BAA0B,EAAuB,MAAM,aAAa,CAAA;AAClF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,qCAAqC,CAAA;AAcxF,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,0BAA0B,EAClC,OAAO,GAAE,6BAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa5C;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,0BAA0B,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY9F"}

package/dist/query-options.js

@@ -0,0 +1,31 @@
+"use client";
+import { queryOptions } from "@tanstack/react-query";
+import { fetchWithValidation } from "./client.js";
+import { sellabilityQueryKeys } from "./query-keys.js";
+import { sellabilityPolicyListResponse, sellabilityPolicySingleResponse } from "./schemas.js";
+function toQueryString(filters) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(filters)) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        params.set(key, String(value));
+    }
+    const qs = params.toString();
+    return qs ? `?${qs}` : "";
+}
+export function getSellabilityPoliciesQueryOptions(client, options = {}) {
+    const { enabled: _enabled = true, ...filters } = options;
+    return queryOptions({
+        queryKey: sellabilityQueryKeys.policiesList(filters),
+        queryFn: () => fetchWithValidation(`/v1/sellability/policies${toQueryString(filters)}`, sellabilityPolicyListResponse, client),
+    });
+}
+export function getSellabilityPolicyQueryOptions(client, id) {
+    return queryOptions({
+        queryKey: sellabilityQueryKeys.policy(id),
+        queryFn: async () => {
+            const { data } = await fetchWithValidation(`/v1/sellability/policies/${id}`, sellabilityPolicySingleResponse, client);
+            return data;
+        },
+    });
+}

package/dist/schemas.d.ts

@@ -0,0 +1,121 @@
+import { z } from "zod";
+export declare const paginatedEnvelope: <T extends z.ZodTypeAny>(item: T) => z.ZodObject<{
+    data: z.ZodArray<T>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export declare const singleEnvelope: <T extends z.ZodTypeAny>(item: T) => z.ZodObject<{
+    data: T;
+}, z.core.$strip>;
+export declare const successEnvelope: z.ZodObject<{
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const sellabilityPolicyRecordSchema: z.ZodObject<{
+    name: z.ZodString;
+    priority: z.ZodDefault<z.ZodNumber>;
+    active: z.ZodDefault<z.ZodBoolean>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    id: z.ZodString;
+    scope: z.ZodEnum<{
+        global: "global";
+        product: "product";
+        option: "option";
+        market: "market";
+        channel: "channel";
+    }>;
+    policyType: z.ZodEnum<{
+        custom: "custom";
+        capability: "capability";
+        occupancy: "occupancy";
+        pickup: "pickup";
+        question: "question";
+        allotment: "allotment";
+        availability_window: "availability_window";
+        currency: "currency";
+    }>;
+    productId: z.ZodNullable<z.ZodString>;
+    optionId: z.ZodNullable<z.ZodString>;
+    marketId: z.ZodNullable<z.ZodString>;
+    channelId: z.ZodNullable<z.ZodString>;
+    conditions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    effects: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type SellabilityPolicyRecord = z.infer<typeof sellabilityPolicyRecordSchema>;
+export declare const sellabilityPolicyListResponse: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        priority: z.ZodDefault<z.ZodNumber>;
+        active: z.ZodDefault<z.ZodBoolean>;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodString;
+        scope: z.ZodEnum<{
+            global: "global";
+            product: "product";
+            option: "option";
+            market: "market";
+            channel: "channel";
+        }>;
+        policyType: z.ZodEnum<{
+            custom: "custom";
+            capability: "capability";
+            occupancy: "occupancy";
+            pickup: "pickup";
+            question: "question";
+            allotment: "allotment";
+            availability_window: "availability_window";
+            currency: "currency";
+        }>;
+        productId: z.ZodNullable<z.ZodString>;
+        optionId: z.ZodNullable<z.ZodString>;
+        marketId: z.ZodNullable<z.ZodString>;
+        channelId: z.ZodNullable<z.ZodString>;
+        conditions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        effects: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export declare const sellabilityPolicySingleResponse: z.ZodObject<{
+    data: z.ZodObject<{
+        name: z.ZodString;
+        priority: z.ZodDefault<z.ZodNumber>;
+        active: z.ZodDefault<z.ZodBoolean>;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodString;
+        scope: z.ZodEnum<{
+            global: "global";
+            product: "product";
+            option: "option";
+            market: "market";
+            channel: "channel";
+        }>;
+        policyType: z.ZodEnum<{
+            custom: "custom";
+            capability: "capability";
+            occupancy: "occupancy";
+            pickup: "pickup";
+            question: "question";
+            allotment: "allotment";
+            availability_window: "availability_window";
+            currency: "currency";
+        }>;
+        productId: z.ZodNullable<z.ZodString>;
+        optionId: z.ZodNullable<z.ZodString>;
+        marketId: z.ZodNullable<z.ZodString>;
+        channelId: z.ZodNullable<z.ZodString>;
+        conditions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        effects: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC;;;;;iBAM7D,CAAA;AAEJ,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC;;iBAA6B,CAAA;AAC3F,eAAO,MAAM,eAAe;;iBAAqC,CAAA;AAEjE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAaxC,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAmD,CAAA;AAC7F,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgD,CAAA"}

package/dist/schemas.js

@@ -0,0 +1,26 @@
+import { insertSellabilityPolicySchema, sellabilityPolicyScopeSchema, sellabilityPolicyTypeSchema, } from "@voyantjs/sellability/validation";
+import { z } from "zod";
+export const paginatedEnvelope = (item) => z.object({
+    data: z.array(item),
+    total: z.number().int(),
+    limit: z.number().int(),
+    offset: z.number().int(),
+});
+export const singleEnvelope = (item) => z.object({ data: item });
+export const successEnvelope = z.object({ success: z.boolean() });
+export const sellabilityPolicyRecordSchema = insertSellabilityPolicySchema.extend({
+    id: z.string(),
+    scope: sellabilityPolicyScopeSchema,
+    policyType: sellabilityPolicyTypeSchema,
+    productId: z.string().nullable(),
+    optionId: z.string().nullable(),
+    marketId: z.string().nullable(),
+    channelId: z.string().nullable(),
+    conditions: z.record(z.string(), z.unknown()),
+    effects: z.record(z.string(), z.unknown()),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const sellabilityPolicyListResponse = paginatedEnvelope(sellabilityPolicyRecordSchema);
+export const sellabilityPolicySingleResponse = singleEnvelope(sellabilityPolicyRecordSchema);

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@voyantjs/sellability-react",
+  "version": "0.2.0",
+  "license": "FSL-1.1-Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/voyantjs/voyant.git",
+    "directory": "packages/sellability-react"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./provider": "./src/provider.tsx",
+    "./hooks": "./src/hooks/index.ts",
+    "./client": "./src/client.ts",
+    "./query-keys": "./src/query-keys.ts"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "prepack": "pnpm run build",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run --passWithNoTests"
+  },
+  "peerDependencies": {
+    "@voyantjs/sellability": "workspace:*",
+    "@tanstack/react-query": "^5.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@tanstack/react-query": "^5.96.2",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@voyantjs/react": "workspace:*",
+    "@voyantjs/sellability": "workspace:*",
+    "@voyantjs/voyant-typescript-config": "workspace:*",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2",
+    "zod": "^4.3.6"
+  },
+  "dependencies": {
+    "@voyantjs/react": "workspace:*"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      },
+      "./provider": {
+        "types": "./dist/provider.d.ts",
+        "import": "./dist/provider.js"
+      },
+      "./hooks": {
+        "types": "./dist/hooks/index.d.ts",
+        "import": "./dist/hooks/index.js"
+      },
+      "./client": {
+        "types": "./dist/client.d.ts",
+        "import": "./dist/client.js"
+      },
+      "./query-keys": {
+        "types": "./dist/query-keys.d.ts",
+        "import": "./dist/query-keys.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  }
+}