@voyant-travel/distribution-react 0.109.8

package/dist/external-refs/i18n/ro.js

@@ -0,0 +1,92 @@
+export const externalRefsUiRo = {
+    common: {
+        refStatusLabels: {
+            active: "Activ",
+            inactive: "Inactiv",
+            archived: "Arhivat",
+        },
+    },
+    externalRefsPage: {
+        title: "Referinte externe",
+        description: "ID-uri din sisteme terte legate de entitati Voyant. Introdu tipul entitatii si ID-ul de mai jos pentru a gestiona referintele externe.",
+        fields: {
+            entityType: "Tip entitate",
+            entity: "Entitate",
+            customEntityType: "Alt tip de entitate",
+        },
+        placeholders: {
+            entityType: "person, booking, product...",
+            entity: "Insereaza o referinta pentru tipuri custom",
+        },
+        entityTypeLabels: {
+            person: "Persoana",
+            organization: "Organizatie",
+            supplier: "Furnizor",
+            booking: "Rezervare",
+            product: "Produs",
+        },
+        emptyScope: "Alege o entitate mai sus pentru a vedea referintele externe.",
+    },
+    externalRefsTab: {
+        description: "Legaturi intre aceasta entitate si ID-uri din sisteme externe.",
+        add: "Adauga referinta externa",
+        empty: {
+            none: "Nu exista inca referinte externe.",
+            loading: "Se incarca referintele externe...",
+        },
+        columns: {
+            sourceSystem: "Sistem sursa",
+            objectType: "Tip obiect",
+            externalId: "ID extern",
+            namespace: "Namespace",
+            status: "Status",
+            primary: "Primara",
+        },
+        actions: {
+            edit: "Editeaza referinta externa",
+            delete: "Sterge referinta externa",
+            deleteConfirm: "Stergi referinta externa?",
+        },
+        pagination: {
+            previous: "Pagina anterioara",
+            next: "Pagina urmatoare",
+            page: "Pagina",
+            of: "din",
+        },
+    },
+    externalRefDialog: {
+        titles: {
+            edit: "Editeaza referinta externa",
+            add: "Adauga referinta externa",
+        },
+        labels: {
+            sourceSystem: "Sistem sursa",
+            objectType: "Tip obiect",
+            namespace: "Namespace",
+            externalId: "ID extern",
+            externalParentId: "ID parinte extern",
+            status: "Status",
+            primary: "Primar",
+            metadataJson: "Metadata (JSON)",
+        },
+        placeholders: {
+            sourceSystem: "bokun, pipedrive, stripe...",
+            objectType: "booking, person, product...",
+            namespace: "default",
+            externalId: "abc-123",
+            externalParentId: "parent-id...",
+            metadataJson: '{ "key": "value" }',
+        },
+        actions: {
+            cancel: "Anuleaza",
+            saveChanges: "Salveaza modificarile",
+            addExternalRef: "Adauga referinta externa",
+        },
+        validation: {
+            sourceSystemRequired: "Sistemul sursa este obligatoriu",
+            objectTypeRequired: "Tipul obiectului este obligatoriu",
+            externalIdRequired: "ID-ul extern este obligatoriu",
+            metadataMustBeObject: "Trebuie sa fie un obiect JSON",
+        },
+    },
+};

package/dist/external-refs/index.d.ts

@@ -0,0 +1,7 @@
+export { defaultFetcher, fetchWithValidation, VoyantApiError, type VoyantFetcher, } from "./client.js";
+export * from "./hooks/index.js";
+export { useVoyantExternalRefsContext, type VoyantExternalRefsContextValue, VoyantExternalRefsProvider, type VoyantExternalRefsProviderProps, } from "./provider.js";
+export { type ExternalRefsListFilters, externalRefsQueryKeys } from "./query-keys.js";
+export { getExternalRefQueryOptions, getExternalRefsQueryOptions } from "./query-options.js";
+export * from "./schemas.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/external-refs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/external-refs/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,4BAA4B,EAC5B,KAAK,8BAA8B,EACnC,0BAA0B,EAC1B,KAAK,+BAA+B,GACrC,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AACrF,OAAO,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAA;AAC5F,cAAc,cAAc,CAAA"}

package/dist/external-refs/index.js

@@ -0,0 +1,6 @@
+export { defaultFetcher, fetchWithValidation, VoyantApiError, } from "./client.js";
+export * from "./hooks/index.js";
+export { useVoyantExternalRefsContext, VoyantExternalRefsProvider, } from "./provider.js";
+export { externalRefsQueryKeys } from "./query-keys.js";
+export { getExternalRefQueryOptions, getExternalRefsQueryOptions } from "./query-options.js";
+export * from "./schemas.js";

package/dist/external-refs/provider.d.ts

@@ -0,0 +1,2 @@
+export { useVoyantReactContext as useVoyantExternalRefsContext, type VoyantReactContextValue as VoyantExternalRefsContextValue, VoyantReactProvider as VoyantExternalRefsProvider, type VoyantReactProviderProps as VoyantExternalRefsProviderProps, } from "@voyant-travel/react";
+//# sourceMappingURL=provider.d.ts.map

package/dist/external-refs/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/external-refs/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,IAAI,4BAA4B,EACrD,KAAK,uBAAuB,IAAI,8BAA8B,EAC9D,mBAAmB,IAAI,0BAA0B,EACjD,KAAK,wBAAwB,IAAI,+BAA+B,GACjE,MAAM,sBAAsB,CAAA"}

package/dist/external-refs/provider.js

@@ -0,0 +1 @@
+export { useVoyantReactContext as useVoyantExternalRefsContext, VoyantReactProvider as VoyantExternalRefsProvider, } from "@voyant-travel/react";

package/dist/external-refs/query-keys.d.ts

@@ -0,0 +1,18 @@
+export interface ExternalRefsListFilters {
+    entityType?: string | undefined;
+    entityId?: string | undefined;
+    sourceSystem?: string | undefined;
+    objectType?: string | undefined;
+    namespace?: string | undefined;
+    status?: string | undefined;
+    search?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}
+export declare const externalRefsQueryKeys: {
+    all: readonly ["external-refs"];
+    refs: () => readonly ["external-refs", "refs"];
+    refsList: (filters: ExternalRefsListFilters) => readonly ["external-refs", "refs", ExternalRefsListFilters];
+    ref: (id: string) => readonly ["external-refs", "refs", string];
+};
+//# sourceMappingURL=query-keys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query-keys.d.ts","sourceRoot":"","sources":["../../src/external-refs/query-keys.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,uBAAuB;IACtC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC5B;AAED,eAAO,MAAM,qBAAqB;;;wBAGZ,uBAAuB;cAEjC,MAAM;CACjB,CAAA"}

package/dist/external-refs/query-keys.js

@@ -0,0 +1,6 @@
+export const externalRefsQueryKeys = {
+    all: ["external-refs"],
+    refs: () => [...externalRefsQueryKeys.all, "refs"],
+    refsList: (filters) => [...externalRefsQueryKeys.refs(), filters],
+    ref: (id) => [...externalRefsQueryKeys.refs(), id],
+};

package/dist/external-refs/query-options.d.ts

@@ -0,0 +1,159 @@
+import { type FetchWithValidationOptions } from "./client.js";
+import type { UseExternalRefsOptions } from "./hooks/use-external-refs.js";
+export declare function getExternalRefsQueryOptions(client: FetchWithValidationOptions, options?: UseExternalRefsOptions): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    data: {
+        entityType: string;
+        entityId: string;
+        sourceSystem: string;
+        objectType: string;
+        namespace: string;
+        externalId: string;
+        isPrimary: boolean;
+        status: "active" | "inactive" | "archived";
+        id: string;
+        externalParentId: string | null;
+        lastSyncedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error, {
+    data: {
+        entityType: string;
+        entityId: string;
+        sourceSystem: string;
+        objectType: string;
+        namespace: string;
+        externalId: string;
+        isPrimary: boolean;
+        status: "active" | "inactive" | "archived";
+        id: string;
+        externalParentId: string | null;
+        lastSyncedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, readonly ["external-refs", "refs", import("./query-keys.js").ExternalRefsListFilters]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        data: {
+            entityType: string;
+            entityId: string;
+            sourceSystem: string;
+            objectType: string;
+            namespace: string;
+            externalId: string;
+            isPrimary: boolean;
+            status: "active" | "inactive" | "archived";
+            id: string;
+            externalParentId: string | null;
+            lastSyncedAt: string | null;
+            createdAt: string;
+            updatedAt: string;
+            metadata?: Record<string, unknown> | null | undefined;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }, readonly ["external-refs", "refs", import("./query-keys.js").ExternalRefsListFilters], never> | undefined;
+} & {
+    queryKey: readonly ["external-refs", "refs", import("./query-keys.js").ExternalRefsListFilters] & {
+        [dataTagSymbol]: {
+            data: {
+                entityType: string;
+                entityId: string;
+                sourceSystem: string;
+                objectType: string;
+                namespace: string;
+                externalId: string;
+                isPrimary: boolean;
+                status: "active" | "inactive" | "archived";
+                id: string;
+                externalParentId: string | null;
+                lastSyncedAt: string | null;
+                createdAt: string;
+                updatedAt: string;
+                metadata?: Record<string, unknown> | null | undefined;
+            }[];
+            total: number;
+            limit: number;
+            offset: number;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function getExternalRefQueryOptions(client: FetchWithValidationOptions, id: string): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    entityType: string;
+    entityId: string;
+    sourceSystem: string;
+    objectType: string;
+    namespace: string;
+    externalId: string;
+    isPrimary: boolean;
+    status: "active" | "inactive" | "archived";
+    id: string;
+    externalParentId: string | null;
+    lastSyncedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown> | null | undefined;
+}, Error, {
+    entityType: string;
+    entityId: string;
+    sourceSystem: string;
+    objectType: string;
+    namespace: string;
+    externalId: string;
+    isPrimary: boolean;
+    status: "active" | "inactive" | "archived";
+    id: string;
+    externalParentId: string | null;
+    lastSyncedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown> | null | undefined;
+}, readonly ["external-refs", "refs", string]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        entityType: string;
+        entityId: string;
+        sourceSystem: string;
+        objectType: string;
+        namespace: string;
+        externalId: string;
+        isPrimary: boolean;
+        status: "active" | "inactive" | "archived";
+        id: string;
+        externalParentId: string | null;
+        lastSyncedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, readonly ["external-refs", "refs", string], never> | undefined;
+} & {
+    queryKey: readonly ["external-refs", "refs", string] & {
+        [dataTagSymbol]: {
+            entityType: string;
+            entityId: string;
+            sourceSystem: string;
+            objectType: string;
+            namespace: string;
+            externalId: string;
+            isPrimary: boolean;
+            status: "active" | "inactive" | "archived";
+            id: string;
+            externalParentId: string | null;
+            lastSyncedAt: string | null;
+            createdAt: string;
+            updatedAt: string;
+            metadata?: Record<string, unknown> | null | undefined;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+//# sourceMappingURL=query-options.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query-options.d.ts","sourceRoot":"","sources":["../../src/external-refs/query-options.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,0BAA0B,EAAuB,MAAM,aAAa,CAAA;AAClF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAA;AAc1E,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,0BAA0B,EAClC,OAAO,GAAE,sBAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYrC;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,0BAA0B,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYxF"}

package/dist/external-refs/query-options.js

@@ -0,0 +1,31 @@
+"use client";
+import { queryOptions } from "@tanstack/react-query";
+import { fetchWithValidation } from "./client.js";
+import { externalRefsQueryKeys } from "./query-keys.js";
+import { externalRefListResponse, externalRefSingleResponse } 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 getExternalRefsQueryOptions(client, options = {}) {
+    const { enabled: _enabled = true, ...filters } = options;
+    return queryOptions({
+        queryKey: externalRefsQueryKeys.refsList(filters),
+        queryFn: () => fetchWithValidation(`/v1/external-refs/refs${toQueryString(filters)}`, externalRefListResponse, client),
+    });
+}
+export function getExternalRefQueryOptions(client, id) {
+    return queryOptions({
+        queryKey: externalRefsQueryKeys.ref(id),
+        queryFn: async () => {
+            const { data } = await fetchWithValidation(`/v1/external-refs/refs/${id}`, externalRefSingleResponse, client);
+            return data;
+        },
+    });
+}

package/dist/external-refs/schemas.d.ts

@@ -0,0 +1,82 @@
+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 externalRefRecordSchema: z.ZodObject<{
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    sourceSystem: z.ZodString;
+    objectType: z.ZodString;
+    namespace: z.ZodDefault<z.ZodString>;
+    externalId: z.ZodString;
+    isPrimary: z.ZodDefault<z.ZodBoolean>;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        archived: "archived";
+    }>>;
+    id: z.ZodString;
+    externalParentId: z.ZodNullable<z.ZodString>;
+    lastSyncedAt: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type ExternalRefRecord = z.infer<typeof externalRefRecordSchema>;
+export declare const externalRefListResponse: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        sourceSystem: z.ZodString;
+        objectType: z.ZodString;
+        namespace: z.ZodDefault<z.ZodString>;
+        externalId: z.ZodString;
+        isPrimary: z.ZodDefault<z.ZodBoolean>;
+        status: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            inactive: "inactive";
+            archived: "archived";
+        }>>;
+        id: z.ZodString;
+        externalParentId: z.ZodNullable<z.ZodString>;
+        lastSyncedAt: z.ZodNullable<z.ZodString>;
+        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 externalRefSingleResponse: z.ZodObject<{
+    data: z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        sourceSystem: z.ZodString;
+        objectType: z.ZodString;
+        namespace: z.ZodDefault<z.ZodString>;
+        externalId: z.ZodString;
+        isPrimary: z.ZodDefault<z.ZodBoolean>;
+        status: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            inactive: "inactive";
+            archived: "archived";
+        }>>;
+        id: z.ZodString;
+        externalParentId: z.ZodNullable<z.ZodString>;
+        lastSyncedAt: z.ZodNullable<z.ZodString>;
+        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/external-refs/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/external-refs/schemas.ts"],"names":[],"mappings":"AACA,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,uBAAuB;;;;;;;;;;;;;;;;;;;iBAOlC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;iBAA6C,CAAA;AACjF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;iBAA0C,CAAA"}

package/dist/external-refs/schemas.js

@@ -0,0 +1,20 @@
+import { insertExternalRefSchema } from "@voyant-travel/distribution";
+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 externalRefRecordSchema = insertExternalRefSchema.extend({
+    id: z.string(),
+    externalParentId: z.string().nullable(),
+    lastSyncedAt: z.string().nullable(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const externalRefListResponse = paginatedEnvelope(externalRefRecordSchema);
+export const externalRefSingleResponse = singleEnvelope(externalRefRecordSchema);

package/dist/external-refs/ui.d.ts

@@ -0,0 +1,5 @@
+export { EntityRefPicker, type EntityRefPickerProps } from "./components/entity-ref-picker.js";
+export { ExternalRefDialog, type ExternalRefDialogProps } from "./components/external-ref-dialog.js";
+export { ExternalRefsPage, type ExternalRefsPageProps, ExternalRefsTab, type ExternalRefsTabProps, } from "./components/external-refs-page.js";
+export { type ExternalRefStatus, type ExternalRefsUiMessageOverrides, type ExternalRefsUiMessages, ExternalRefsUiMessagesProvider, externalRefsUiEn, externalRefsUiMessageDefinitions, externalRefsUiRo, getExternalRefsUiI18n, resolveExternalRefsUiMessages, useExternalRefsUiI18n, useExternalRefsUiI18nOrDefault, useExternalRefsUiMessages, useExternalRefsUiMessagesOrDefault, } from "./i18n/index.js";
+//# sourceMappingURL=ui.d.ts.map

package/dist/external-refs/ui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.d.ts","sourceRoot":"","sources":["../../src/external-refs/ui.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,mCAAmC,CAAA;AAC9F,OAAO,EAAE,iBAAiB,EAAE,KAAK,sBAAsB,EAAE,MAAM,qCAAqC,CAAA;AACpG,OAAO,EACL,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,eAAe,EACf,KAAK,oBAAoB,GAC1B,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,8BAA8B,EACnC,KAAK,sBAAsB,EAC3B,8BAA8B,EAC9B,gBAAgB,EAChB,gCAAgC,EAChC,gBAAgB,EAChB,qBAAqB,EACrB,6BAA6B,EAC7B,qBAAqB,EACrB,8BAA8B,EAC9B,yBAAyB,EACzB,kCAAkC,GACnC,MAAM,iBAAiB,CAAA"}

package/dist/external-refs/ui.js

@@ -0,0 +1,4 @@
+export { EntityRefPicker } from "./components/entity-ref-picker.js";
+export { ExternalRefDialog } from "./components/external-ref-dialog.js";
+export { ExternalRefsPage, ExternalRefsTab, } from "./components/external-refs-page.js";
+export { ExternalRefsUiMessagesProvider, externalRefsUiEn, externalRefsUiMessageDefinitions, externalRefsUiRo, getExternalRefsUiI18n, resolveExternalRefsUiMessages, useExternalRefsUiI18n, useExternalRefsUiI18nOrDefault, useExternalRefsUiMessages, useExternalRefsUiMessagesOrDefault, } from "./i18n/index.js";

package/dist/hooks/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./use-booking-links.js";
+export * from "./use-bookings.js";
+export * from "./use-channel.js";
+export * from "./use-channel-mutation.js";
+export * from "./use-channels.js";
+export * from "./use-commission-rules.js";
+export * from "./use-contracts.js";
+export * from "./use-mappings.js";
+export * from "./use-products.js";
+export * from "./use-suppliers.js";
+export * from "./use-webhook-events.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":"AAEA,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,2BAA2B,CAAA;AACzC,cAAc,mBAAmB,CAAA;AACjC,cAAc,2BAA2B,CAAA;AACzC,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA"}

package/dist/hooks/index.js

@@ -0,0 +1,12 @@
+"use client";
+export * from "./use-booking-links.js";
+export * from "./use-bookings.js";
+export * from "./use-channel.js";
+export * from "./use-channel-mutation.js";
+export * from "./use-channels.js";
+export * from "./use-commission-rules.js";
+export * from "./use-contracts.js";
+export * from "./use-mappings.js";
+export * from "./use-products.js";
+export * from "./use-suppliers.js";
+export * from "./use-webhook-events.js";

package/dist/hooks/use-booking-links.d.ts

@@ -0,0 +1,20 @@
+import type { BookingLinksListFilters } from "../query-keys.js";
+export interface UseBookingLinksOptions extends BookingLinksListFilters {
+    enabled?: boolean;
+}
+export declare function useBookingLinks(options?: UseBookingLinksOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        channelId: string;
+        bookingId: string;
+        externalBookingId: string | null;
+        externalReference: string | null;
+        externalStatus: string | null;
+        bookedAtExternal: string | null;
+        lastSyncedAt: string | null;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-booking-links.d.ts.map

package/dist/hooks/use-booking-links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-booking-links.d.ts","sourceRoot":"","sources":["../../src/hooks/use-booking-links.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAA;AAG/D,MAAM,WAAW,sBAAuB,SAAQ,uBAAuB;IACrE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B;;;;;;;;;;;;;;UAInE"}

package/dist/hooks/use-booking-links.js

@@ -0,0 +1,9 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantDistributionContext } from "../provider.js";
+import { getBookingLinksQueryOptions } from "../query-options.js";
+export function useBookingLinks(options = {}) {
+    const client = useVoyantDistributionContext();
+    const { enabled = true } = options;
+    return useQuery({ ...getBookingLinksQueryOptions(client, options), enabled });
+}

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

@@ -0,0 +1,14 @@
+import type { BookingsListFilters } from "../query-keys.js";
+export interface UseBookingsOptions extends BookingsListFilters {
+    enabled?: boolean;
+}
+export declare function useBookings(options?: UseBookingsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        bookingNumber: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-bookings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-bookings.d.ts","sourceRoot":"","sources":["../../src/hooks/use-bookings.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAG3D,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB;;;;;;;;UAI3D"}

package/dist/hooks/use-bookings.js

@@ -0,0 +1,9 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantDistributionContext } from "../provider.js";
+import { getBookingsQueryOptions } from "../query-options.js";
+export function useBookings(options = {}) {
+    const client = useVoyantDistributionContext();
+    const { enabled = true } = options;
+    return useQuery({ ...getBookingsQueryOptions(client, options), enabled });
+}

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

@@ -0,0 +1,69 @@
+import { z } from "zod";
+declare const channelInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodEnum<{
+        direct: "direct";
+        affiliate: "affiliate";
+        ota: "ota";
+        reseller: "reseller";
+        marketplace: "marketplace";
+        api_partner: "api_partner";
+        connect: "connect";
+    }>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        pending: "pending";
+        archived: "archived";
+    }>>;
+    website: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    contactName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    contactEmail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export type CreateChannelInput = z.input<typeof channelInputSchema>;
+export type UpdateChannelInput = Partial<CreateChannelInput>;
+export declare function useChannelMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        name: string;
+        kind: "direct" | "affiliate" | "ota" | "reseller" | "marketplace" | "api_partner" | "connect";
+        status: "active" | "inactive" | "pending" | "archived";
+        website: string | null;
+        contactName: string | null;
+        contactEmail: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        name: string;
+        kind: "direct" | "affiliate" | "ota" | "reseller" | "marketplace" | "api_partner" | "connect";
+        description?: string | null | undefined;
+        status?: "active" | "inactive" | "pending" | "archived" | undefined;
+        website?: string | null | undefined;
+        contactName?: string | null | undefined;
+        contactEmail?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        name: string;
+        kind: "direct" | "affiliate" | "ota" | "reseller" | "marketplace" | "api_partner" | "connect";
+        status: "active" | "inactive" | "pending" | "archived";
+        website: string | null;
+        contactName: string | null;
+        contactEmail: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        id: string;
+        input: UpdateChannelInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+export {};
+//# sourceMappingURL=use-channel-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-channel-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-channel-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;iBAStB,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACnE,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;AAE5D,wBAAgB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBU,MAAM;eAAS,kBAAkB;;;;;EA8B5E"}