@voyantjs/markets-react 0.2.0

package/dist/query-options.d.ts

@@ -0,0 +1,337 @@
+import { type FetchWithValidationOptions } from "./client.js";
+import type { UseMarketCurrenciesOptions } from "./hooks/use-market-currencies.js";
+import type { UseMarketLocalesOptions } from "./hooks/use-market-locales.js";
+import type { UseMarketsOptions } from "./hooks/use-markets.js";
+export declare function getMarketsQueryOptions(client: FetchWithValidationOptions, options?: UseMarketsOptions): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    data: {
+        code: string;
+        name: string;
+        status: "active" | "inactive" | "archived";
+        defaultLanguageTag: string;
+        defaultCurrency: string;
+        id: string;
+        regionCode: string | null;
+        countryCode: string | null;
+        timezone: string | null;
+        taxContext: string | null;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error, {
+    data: {
+        code: string;
+        name: string;
+        status: "active" | "inactive" | "archived";
+        defaultLanguageTag: string;
+        defaultCurrency: string;
+        id: string;
+        regionCode: string | null;
+        countryCode: string | null;
+        timezone: string | null;
+        taxContext: string | null;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, readonly ["markets", "markets", import("./query-keys.js").MarketsListFilters]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        data: {
+            code: string;
+            name: string;
+            status: "active" | "inactive" | "archived";
+            defaultLanguageTag: string;
+            defaultCurrency: string;
+            id: string;
+            regionCode: string | null;
+            countryCode: string | null;
+            timezone: string | null;
+            taxContext: string | null;
+            metadata?: Record<string, unknown> | null | undefined;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }, readonly ["markets", "markets", import("./query-keys.js").MarketsListFilters], never> | undefined;
+} & {
+    queryKey: readonly ["markets", "markets", import("./query-keys.js").MarketsListFilters] & {
+        [dataTagSymbol]: {
+            data: {
+                code: string;
+                name: string;
+                status: "active" | "inactive" | "archived";
+                defaultLanguageTag: string;
+                defaultCurrency: string;
+                id: string;
+                regionCode: string | null;
+                countryCode: string | null;
+                timezone: string | null;
+                taxContext: string | null;
+                metadata?: Record<string, unknown> | null | undefined;
+            }[];
+            total: number;
+            limit: number;
+            offset: number;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function getMarketQueryOptions(client: FetchWithValidationOptions, id: string): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    code: string;
+    name: string;
+    status: "active" | "inactive" | "archived";
+    defaultLanguageTag: string;
+    defaultCurrency: string;
+    id: string;
+    regionCode: string | null;
+    countryCode: string | null;
+    timezone: string | null;
+    taxContext: string | null;
+    metadata?: Record<string, unknown> | null | undefined;
+}, Error, {
+    code: string;
+    name: string;
+    status: "active" | "inactive" | "archived";
+    defaultLanguageTag: string;
+    defaultCurrency: string;
+    id: string;
+    regionCode: string | null;
+    countryCode: string | null;
+    timezone: string | null;
+    taxContext: string | null;
+    metadata?: Record<string, unknown> | null | undefined;
+}, readonly ["markets", "markets", string]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        code: string;
+        name: string;
+        status: "active" | "inactive" | "archived";
+        defaultLanguageTag: string;
+        defaultCurrency: string;
+        id: string;
+        regionCode: string | null;
+        countryCode: string | null;
+        timezone: string | null;
+        taxContext: string | null;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, readonly ["markets", "markets", string], never> | undefined;
+} & {
+    queryKey: readonly ["markets", "markets", string] & {
+        [dataTagSymbol]: {
+            code: string;
+            name: string;
+            status: "active" | "inactive" | "archived";
+            defaultLanguageTag: string;
+            defaultCurrency: string;
+            id: string;
+            regionCode: string | null;
+            countryCode: string | null;
+            timezone: string | null;
+            taxContext: string | null;
+            metadata?: Record<string, unknown> | null | undefined;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function getMarketLocalesQueryOptions(client: FetchWithValidationOptions, options: UseMarketLocalesOptions): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    data: {
+        languageTag: string;
+        isDefault: boolean;
+        sortOrder: number;
+        active: boolean;
+        id: string;
+        marketId: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error, {
+    data: {
+        languageTag: string;
+        isDefault: boolean;
+        sortOrder: number;
+        active: boolean;
+        id: string;
+        marketId: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, readonly ["markets", "market-locales", import("./query-keys.js").MarketLocalesListFilters]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        data: {
+            languageTag: string;
+            isDefault: boolean;
+            sortOrder: number;
+            active: boolean;
+            id: string;
+            marketId: string;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }, readonly ["markets", "market-locales", import("./query-keys.js").MarketLocalesListFilters], never> | undefined;
+} & {
+    queryKey: readonly ["markets", "market-locales", import("./query-keys.js").MarketLocalesListFilters] & {
+        [dataTagSymbol]: {
+            data: {
+                languageTag: string;
+                isDefault: boolean;
+                sortOrder: number;
+                active: boolean;
+                id: string;
+                marketId: string;
+            }[];
+            total: number;
+            limit: number;
+            offset: number;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function getMarketLocaleQueryOptions(client: FetchWithValidationOptions, id: string): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    languageTag: string;
+    isDefault: boolean;
+    sortOrder: number;
+    active: boolean;
+    id: string;
+    marketId: string;
+}, Error, {
+    languageTag: string;
+    isDefault: boolean;
+    sortOrder: number;
+    active: boolean;
+    id: string;
+    marketId: string;
+}, readonly ["markets", "market-locales", string]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        languageTag: string;
+        isDefault: boolean;
+        sortOrder: number;
+        active: boolean;
+        id: string;
+        marketId: string;
+    }, readonly ["markets", "market-locales", string], never> | undefined;
+} & {
+    queryKey: readonly ["markets", "market-locales", string] & {
+        [dataTagSymbol]: {
+            languageTag: string;
+            isDefault: boolean;
+            sortOrder: number;
+            active: boolean;
+            id: string;
+            marketId: string;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function getMarketCurrenciesQueryOptions(client: FetchWithValidationOptions, options: UseMarketCurrenciesOptions): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    data: {
+        currencyCode: string;
+        isDefault: boolean;
+        isSettlement: boolean;
+        isReporting: boolean;
+        sortOrder: number;
+        active: boolean;
+        id: string;
+        marketId: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error, {
+    data: {
+        currencyCode: string;
+        isDefault: boolean;
+        isSettlement: boolean;
+        isReporting: boolean;
+        sortOrder: number;
+        active: boolean;
+        id: string;
+        marketId: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, readonly ["markets", "market-currencies", import("./query-keys.js").MarketCurrenciesListFilters]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        data: {
+            currencyCode: string;
+            isDefault: boolean;
+            isSettlement: boolean;
+            isReporting: boolean;
+            sortOrder: number;
+            active: boolean;
+            id: string;
+            marketId: string;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }, readonly ["markets", "market-currencies", import("./query-keys.js").MarketCurrenciesListFilters], never> | undefined;
+} & {
+    queryKey: readonly ["markets", "market-currencies", import("./query-keys.js").MarketCurrenciesListFilters] & {
+        [dataTagSymbol]: {
+            data: {
+                currencyCode: string;
+                isDefault: boolean;
+                isSettlement: boolean;
+                isReporting: boolean;
+                sortOrder: number;
+                active: boolean;
+                id: string;
+                marketId: string;
+            }[];
+            total: number;
+            limit: number;
+            offset: number;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function getMarketCurrencyQueryOptions(client: FetchWithValidationOptions, id: string): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    currencyCode: string;
+    isDefault: boolean;
+    isSettlement: boolean;
+    isReporting: boolean;
+    sortOrder: number;
+    active: boolean;
+    id: string;
+    marketId: string;
+}, Error, {
+    currencyCode: string;
+    isDefault: boolean;
+    isSettlement: boolean;
+    isReporting: boolean;
+    sortOrder: number;
+    active: boolean;
+    id: string;
+    marketId: string;
+}, readonly ["markets", "market-currencies", string]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        currencyCode: string;
+        isDefault: boolean;
+        isSettlement: boolean;
+        isReporting: boolean;
+        sortOrder: number;
+        active: boolean;
+        id: string;
+        marketId: string;
+    }, readonly ["markets", "market-currencies", string], never> | undefined;
+} & {
+    queryKey: readonly ["markets", "market-currencies", string] & {
+        [dataTagSymbol]: {
+            currencyCode: string;
+            isDefault: boolean;
+            isSettlement: boolean;
+            isReporting: boolean;
+            sortOrder: number;
+            active: boolean;
+            id: string;
+            marketId: string;
+        };
+        [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,0BAA0B,EAAE,MAAM,kCAAkC,CAAA;AAClF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAA;AAC5E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAqB/D,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,0BAA0B,EAClC,OAAO,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYhC;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,0BAA0B,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYnF;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,0BAA0B,EAClC,OAAO,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcjC;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,0BAA0B,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYzF;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,0BAA0B,EAClC,OAAO,EAAE,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcpC;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,0BAA0B,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY3F"}

package/dist/query-options.js

@@ -0,0 +1,71 @@
+"use client";
+import { queryOptions } from "@tanstack/react-query";
+import { fetchWithValidation } from "./client.js";
+import { marketsQueryKeys } from "./query-keys.js";
+import { marketCurrencyListResponse, marketCurrencySingleResponse, marketListResponse, marketLocaleListResponse, marketLocaleSingleResponse, marketSingleResponse, } 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 getMarketsQueryOptions(client, options = {}) {
+    const { enabled: _enabled = true, ...filters } = options;
+    return queryOptions({
+        queryKey: marketsQueryKeys.marketsList(filters),
+        queryFn: () => fetchWithValidation(`/v1/markets/markets${toQueryString(filters)}`, marketListResponse, client),
+    });
+}
+export function getMarketQueryOptions(client, id) {
+    return queryOptions({
+        queryKey: marketsQueryKeys.market(id),
+        queryFn: async () => {
+            const { data } = await fetchWithValidation(`/v1/markets/markets/${id}`, marketSingleResponse, client);
+            return data;
+        },
+    });
+}
+export function getMarketLocalesQueryOptions(client, options) {
+    const { enabled: _enabled = true, ...filters } = options;
+    return queryOptions({
+        queryKey: marketsQueryKeys.marketLocalesList(filters),
+        queryFn: async () => {
+            if (!filters.marketId)
+                throw new Error("getMarketLocalesQueryOptions requires a marketId");
+            return fetchWithValidation(`/v1/markets/market-locales${toQueryString(filters)}`, marketLocaleListResponse, client);
+        },
+    });
+}
+export function getMarketLocaleQueryOptions(client, id) {
+    return queryOptions({
+        queryKey: marketsQueryKeys.marketLocale(id),
+        queryFn: async () => {
+            const { data } = await fetchWithValidation(`/v1/markets/market-locales/${id}`, marketLocaleSingleResponse, client);
+            return data;
+        },
+    });
+}
+export function getMarketCurrenciesQueryOptions(client, options) {
+    const { enabled: _enabled = true, ...filters } = options;
+    return queryOptions({
+        queryKey: marketsQueryKeys.marketCurrenciesList(filters),
+        queryFn: async () => {
+            if (!filters.marketId)
+                throw new Error("getMarketCurrenciesQueryOptions requires a marketId");
+            return fetchWithValidation(`/v1/markets/market-currencies${toQueryString(filters)}`, marketCurrencyListResponse, client);
+        },
+    });
+}
+export function getMarketCurrencyQueryOptions(client, id) {
+    return queryOptions({
+        queryKey: marketsQueryKeys.marketCurrency(id),
+        queryFn: async () => {
+            const { data } = await fetchWithValidation(`/v1/markets/market-currencies/${id}`, marketCurrencySingleResponse, client);
+            return data;
+        },
+    });
+}

package/dist/schemas.d.ts

@@ -0,0 +1,143 @@
+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 marketRecordSchema: z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        archived: "archived";
+    }>>;
+    defaultLanguageTag: z.ZodString;
+    defaultCurrency: z.ZodString;
+    id: z.ZodString;
+    regionCode: z.ZodNullable<z.ZodString>;
+    countryCode: z.ZodNullable<z.ZodString>;
+    timezone: z.ZodNullable<z.ZodString>;
+    taxContext: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export type MarketRecord = z.infer<typeof marketRecordSchema>;
+export declare const marketLocaleRecordSchema: z.ZodObject<{
+    languageTag: z.ZodString;
+    isDefault: z.ZodDefault<z.ZodBoolean>;
+    sortOrder: z.ZodDefault<z.ZodNumber>;
+    active: z.ZodDefault<z.ZodBoolean>;
+    id: z.ZodString;
+    marketId: z.ZodString;
+}, z.core.$strip>;
+export type MarketLocaleRecord = z.infer<typeof marketLocaleRecordSchema>;
+export declare const marketCurrencyRecordSchema: z.ZodObject<{
+    currencyCode: z.ZodString;
+    isDefault: z.ZodDefault<z.ZodBoolean>;
+    isSettlement: z.ZodDefault<z.ZodBoolean>;
+    isReporting: z.ZodDefault<z.ZodBoolean>;
+    sortOrder: z.ZodDefault<z.ZodNumber>;
+    active: z.ZodDefault<z.ZodBoolean>;
+    id: z.ZodString;
+    marketId: z.ZodString;
+}, z.core.$strip>;
+export type MarketCurrencyRecord = z.infer<typeof marketCurrencyRecordSchema>;
+export declare const marketListResponse: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            inactive: "inactive";
+            archived: "archived";
+        }>>;
+        defaultLanguageTag: z.ZodString;
+        defaultCurrency: z.ZodString;
+        id: z.ZodString;
+        regionCode: z.ZodNullable<z.ZodString>;
+        countryCode: z.ZodNullable<z.ZodString>;
+        timezone: z.ZodNullable<z.ZodString>;
+        taxContext: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export declare const marketSingleResponse: z.ZodObject<{
+    data: z.ZodObject<{
+        code: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            inactive: "inactive";
+            archived: "archived";
+        }>>;
+        defaultLanguageTag: z.ZodString;
+        defaultCurrency: z.ZodString;
+        id: z.ZodString;
+        regionCode: z.ZodNullable<z.ZodString>;
+        countryCode: z.ZodNullable<z.ZodString>;
+        timezone: z.ZodNullable<z.ZodString>;
+        taxContext: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const marketLocaleListResponse: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        languageTag: z.ZodString;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        sortOrder: z.ZodDefault<z.ZodNumber>;
+        active: z.ZodDefault<z.ZodBoolean>;
+        id: z.ZodString;
+        marketId: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export declare const marketLocaleSingleResponse: z.ZodObject<{
+    data: z.ZodObject<{
+        languageTag: z.ZodString;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        sortOrder: z.ZodDefault<z.ZodNumber>;
+        active: z.ZodDefault<z.ZodBoolean>;
+        id: z.ZodString;
+        marketId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const marketCurrencyListResponse: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        currencyCode: z.ZodString;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        isSettlement: z.ZodDefault<z.ZodBoolean>;
+        isReporting: z.ZodDefault<z.ZodBoolean>;
+        sortOrder: z.ZodDefault<z.ZodNumber>;
+        active: z.ZodDefault<z.ZodBoolean>;
+        id: z.ZodString;
+        marketId: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export declare const marketCurrencySingleResponse: z.ZodObject<{
+    data: z.ZodObject<{
+        currencyCode: z.ZodString;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        isSettlement: z.ZodDefault<z.ZodBoolean>;
+        isReporting: z.ZodDefault<z.ZodBoolean>;
+        sortOrder: z.ZodDefault<z.ZodNumber>;
+        active: z.ZodDefault<z.ZodBoolean>;
+        id: z.ZodString;
+        marketId: 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,kBAAkB;;;;;;;;;;;;;;;;iBAO7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,wBAAwB;;;;;;;iBAGnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,0BAA0B;;;;;;;;;iBAGrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;iBAAwC,CAAA;AACvE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;iBAAqC,CAAA;AACtE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAA8C,CAAA;AACnF,eAAO,MAAM,0BAA0B;;;;;;;;;iBAA2C,CAAA;AAClF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;iBAAgD,CAAA;AACvF,eAAO,MAAM,4BAA4B;;;;;;;;;;;iBAA6C,CAAA"}

package/dist/schemas.js

@@ -0,0 +1,32 @@
+import { insertMarketCurrencySchema, insertMarketLocaleSchema, insertMarketSchema, } from "@voyantjs/markets";
+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 marketRecordSchema = insertMarketSchema.extend({
+    id: z.string(),
+    regionCode: z.string().nullable(),
+    countryCode: z.string().nullable(),
+    timezone: z.string().nullable(),
+    taxContext: z.string().nullable(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+});
+export const marketLocaleRecordSchema = insertMarketLocaleSchema.extend({
+    id: z.string(),
+    marketId: z.string(),
+});
+export const marketCurrencyRecordSchema = insertMarketCurrencySchema.extend({
+    id: z.string(),
+    marketId: z.string(),
+});
+export const marketListResponse = paginatedEnvelope(marketRecordSchema);
+export const marketSingleResponse = singleEnvelope(marketRecordSchema);
+export const marketLocaleListResponse = paginatedEnvelope(marketLocaleRecordSchema);
+export const marketLocaleSingleResponse = singleEnvelope(marketLocaleRecordSchema);
+export const marketCurrencyListResponse = paginatedEnvelope(marketCurrencyRecordSchema);
+export const marketCurrencySingleResponse = singleEnvelope(marketCurrencyRecordSchema);

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@voyantjs/markets-react",
+  "version": "0.2.0",
+  "license": "FSL-1.1-Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/voyantjs/voyant.git",
+    "directory": "packages/markets-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/markets": "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/markets": "workspace:*",
+    "@voyantjs/react": "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"
+  }
+}