@voyant-travel/notifications-react 0.111.7

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

@@ -0,0 +1,54 @@
+import type { insertNotificationTemplateSchema, updateNotificationTemplateSchema } from "@voyant-travel/notifications";
+import type { z } from "zod";
+export type CreateNotificationTemplateInput = z.input<typeof insertNotificationTemplateSchema>;
+export type UpdateNotificationTemplateInput = z.input<typeof updateNotificationTemplateSchema>;
+export declare function useNotificationTemplateMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        slug: string;
+        name: string;
+        channel: "email" | "sms";
+        provider: string | null;
+        status: "draft" | "active" | "archived";
+        subjectTemplate: string | null;
+        htmlTemplate: string | null;
+        textTemplate: string | null;
+        fromAddress: string | null;
+        isSystem: boolean;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        slug: string;
+        name: string;
+        channel: "email" | "sms";
+        provider?: string | null | undefined;
+        status?: "draft" | "active" | "archived" | undefined;
+        subjectTemplate?: string | null | undefined;
+        htmlTemplate?: string | null | undefined;
+        textTemplate?: string | null | undefined;
+        fromAddress?: string | null | undefined;
+        isSystem?: boolean | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        slug: string;
+        name: string;
+        channel: "email" | "sms";
+        provider: string | null;
+        status: "draft" | "active" | "archived";
+        subjectTemplate: string | null;
+        htmlTemplate: string | null;
+        textTemplate: string | null;
+        fromAddress: string | null;
+        isSystem: boolean;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        id: string;
+        input: UpdateNotificationTemplateInput;
+    }, unknown>;
+};
+//# sourceMappingURL=use-notification-template-mutation.d.ts.map

package/dist/hooks/use-notification-template-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-notification-template-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-notification-template-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,gCAAgC,EAChC,gCAAgC,EACjC,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAO5B,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAC9F,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAE9F,wBAAgB,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBH,MAAM;eAAS,+BAA+B;;EAgBzF"}

package/dist/hooks/use-notification-template-mutation.js

@@ -0,0 +1,31 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantNotificationsContext } from "../provider.js";
+import { notificationsQueryKeys } from "../query-keys.js";
+import { notificationTemplateSingleResponse } from "../schemas.js";
+export function useNotificationTemplateMutation() {
+    const { baseUrl, fetcher } = useVoyantNotificationsContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/admin/notifications/templates", notificationTemplateSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: notificationsQueryKeys.templates() });
+            queryClient.setQueryData(notificationsQueryKeys.template(data.id), data);
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/admin/notifications/templates/${id}`, notificationTemplateSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: notificationsQueryKeys.templates() });
+            queryClient.setQueryData(notificationsQueryKeys.template(data.id), data);
+        },
+    });
+    return { create, update };
+}

package/dist/hooks/use-notification-template-tools.d.ts

@@ -0,0 +1,80 @@
+import type { previewNotificationTemplateSchema, sendNotificationSchema } from "@voyant-travel/notifications";
+import type { z } from "zod";
+export type PreviewNotificationTemplateInput = z.input<typeof previewNotificationTemplateSchema>;
+export type SendNotificationInput = z.input<typeof sendNotificationSchema>;
+export declare function useNotificationTemplateTools(): {
+    preview: import("@tanstack/react-query").UseMutationResult<{
+        channel: "email" | "sms";
+        provider: string | null;
+        fromAddress: string | null;
+        subject: string | null;
+        html: string | null;
+        text: string | null;
+    }, Error, {
+        channel: "email" | "sms";
+        provider?: string | null | undefined;
+        subjectTemplate?: string | null | undefined;
+        htmlTemplate?: string | null | undefined;
+        textTemplate?: string | null | undefined;
+        fromAddress?: string | null | undefined;
+        data?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    testSend: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        templateId: string | null;
+        templateSlug: string | null;
+        targetType: "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "person" | "organization" | "payment_session";
+        targetId: string | null;
+        personId: string | null;
+        organizationId: string | null;
+        bookingId: string | null;
+        invoiceId: string | null;
+        paymentSessionId: string | null;
+        channel: "email" | "sms";
+        provider: string;
+        providerMessageId: string | null;
+        status: "pending" | "failed" | "cancelled" | "sent";
+        toAddress: string;
+        fromAddress: string | null;
+        subject: string | null;
+        htmlBody: string | null;
+        textBody: string | null;
+        payloadData: Record<string, unknown> | null;
+        metadata: Record<string, unknown> | null;
+        errorMessage: string | null;
+        scheduledFor: string | null;
+        sentAt: string | null;
+        failedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        to: string;
+        templateId?: string | null | undefined;
+        templateSlug?: string | null | undefined;
+        channel?: "email" | "sms" | undefined;
+        provider?: string | null | undefined;
+        from?: string | null | undefined;
+        subject?: string | null | undefined;
+        html?: string | null | undefined;
+        text?: string | null | undefined;
+        attachments?: {
+            filename: string;
+            contentBase64?: string | null | undefined;
+            path?: string | null | undefined;
+            contentType?: string | null | undefined;
+            disposition?: "inline" | "attachment" | null | undefined;
+            contentId?: string | null | undefined;
+        }[] | null | undefined;
+        data?: Record<string, unknown> | null | undefined;
+        targetType?: "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "person" | "organization" | "payment_session" | undefined;
+        targetId?: string | null | undefined;
+        bookingId?: string | null | undefined;
+        invoiceId?: string | null | undefined;
+        paymentSessionId?: string | null | undefined;
+        personId?: string | null | undefined;
+        organizationId?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+        scheduledFor?: string | null | undefined;
+    }, unknown>;
+};
+//# sourceMappingURL=use-notification-template-tools.d.ts.map

package/dist/hooks/use-notification-template-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-notification-template-tools.d.ts","sourceRoot":"","sources":["../../src/hooks/use-notification-template-tools.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,iCAAiC,EACjC,sBAAsB,EACvB,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAS5B,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAChG,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE1E,wBAAgB,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4B3C"}

package/dist/hooks/use-notification-template-tools.js

@@ -0,0 +1,21 @@
+"use client";
+import { useMutation } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantNotificationsContext } from "../provider.js";
+import { notificationDeliverySingleResponse, notificationTemplatePreviewResponse, } from "../schemas.js";
+export function useNotificationTemplateTools() {
+    const { baseUrl, fetcher } = useVoyantNotificationsContext();
+    const preview = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/admin/notifications/preview", notificationTemplatePreviewResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+    });
+    const testSend = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/admin/notifications/send", notificationDeliverySingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+    });
+    return { preview, testSend };
+}

package/dist/hooks/use-notification-template.d.ts

@@ -0,0 +1,20 @@
+export interface UseNotificationTemplateOptions {
+    enabled?: boolean;
+}
+export declare function useNotificationTemplate(id: string, options?: UseNotificationTemplateOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    slug: string;
+    name: string;
+    channel: "email" | "sms";
+    provider: string | null;
+    status: "draft" | "active" | "archived";
+    subjectTemplate: string | null;
+    htmlTemplate: string | null;
+    textTemplate: string | null;
+    fromAddress: string | null;
+    isSystem: boolean;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}, Error>;
+//# sourceMappingURL=use-notification-template.d.ts.map

package/dist/hooks/use-notification-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-notification-template.d.ts","sourceRoot":"","sources":["../../src/hooks/use-notification-template.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,8BAA8B;IAC7C,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,8BAAmC;;;;;;;;;;;;;;;UAO/F"}

package/dist/hooks/use-notification-template.js

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

package/dist/hooks/use-notification-templates.d.ts

@@ -0,0 +1,26 @@
+import type { NotificationTemplatesListFilters } from "../query-keys.js";
+export interface UseNotificationTemplatesOptions extends NotificationTemplatesListFilters {
+    enabled?: boolean;
+}
+export declare function useNotificationTemplates(options?: UseNotificationTemplatesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        slug: string;
+        name: string;
+        channel: "email" | "sms";
+        provider: string | null;
+        status: "draft" | "active" | "archived";
+        subjectTemplate: string | null;
+        htmlTemplate: string | null;
+        textTemplate: string | null;
+        fromAddress: string | null;
+        isSystem: boolean;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-notification-templates.d.ts.map

package/dist/hooks/use-notification-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-notification-templates.d.ts","sourceRoot":"","sources":["../../src/hooks/use-notification-templates.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,kBAAkB,CAAA;AAGxE,MAAM,WAAW,+BAAgC,SAAQ,gCAAgC;IACvF,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,+BAAoC;;;;;;;;;;;;;;;;;;;;UAOrF"}

package/dist/hooks/use-notification-templates.js

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

package/dist/hooks/use-reminder-rule-stage-mutation.d.ts

@@ -0,0 +1,93 @@
+import type { insertNotificationReminderRuleStageSchema, reorderReminderRuleStagesSchema, updateNotificationReminderRuleStageSchema } from "@voyant-travel/notifications";
+import type { z } from "zod";
+export type CreateReminderRuleStageInput = z.input<typeof insertNotificationReminderRuleStageSchema>;
+export type UpdateReminderRuleStageInput = z.input<typeof updateNotificationReminderRuleStageSchema>;
+export type ReorderReminderRuleStagesInput = z.input<typeof reorderReminderRuleStagesSchema>;
+export declare function useReminderRuleStageMutation(reminderRuleId: string): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        reminderRuleId: string;
+        orderIndex: number;
+        name: string | null;
+        anchor: "due_date" | "booking_created_at" | "departure_date" | "invoice_issued_at" | "last_send_at";
+        windowStartDays: number;
+        windowEndDays: number;
+        cadenceKind: "once" | "every_n_days" | "escalating";
+        cadenceEveryDays: number | null;
+        cadenceIntervals: {
+            repeatEveryDays: number;
+            whenDaysUntilDueGT?: number | null | undefined;
+            whenDaysUntilDueLT?: number | null | undefined;
+        }[] | null;
+        maxSendsInStage: number | null;
+        respectQuietHours: boolean;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        orderIndex: unknown;
+        anchor: "due_date" | "booking_created_at" | "departure_date" | "invoice_issued_at" | "last_send_at";
+        windowStartDays: unknown;
+        windowEndDays: unknown;
+        cadenceKind: "once" | "every_n_days" | "escalating";
+        name?: string | null | undefined;
+        cadenceEveryDays?: unknown;
+        cadenceIntervals?: {
+            repeatEveryDays: unknown;
+            whenDaysUntilDueGT?: unknown;
+            whenDaysUntilDueLT?: unknown;
+        }[] | null | undefined;
+        maxSendsInStage?: unknown;
+        respectQuietHours?: boolean | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        reminderRuleId: string;
+        orderIndex: number;
+        name: string | null;
+        anchor: "due_date" | "booking_created_at" | "departure_date" | "invoice_issued_at" | "last_send_at";
+        windowStartDays: number;
+        windowEndDays: number;
+        cadenceKind: "once" | "every_n_days" | "escalating";
+        cadenceEveryDays: number | null;
+        cadenceIntervals: {
+            repeatEveryDays: number;
+            whenDaysUntilDueGT?: number | null | undefined;
+            whenDaysUntilDueLT?: number | null | undefined;
+        }[] | null;
+        maxSendsInStage: number | null;
+        respectQuietHours: boolean;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        stageId: string;
+        input: UpdateReminderRuleStageInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<string, Error, string, unknown>;
+    reorder: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        reminderRuleId: string;
+        orderIndex: number;
+        name: string | null;
+        anchor: "due_date" | "booking_created_at" | "departure_date" | "invoice_issued_at" | "last_send_at";
+        windowStartDays: number;
+        windowEndDays: number;
+        cadenceKind: "once" | "every_n_days" | "escalating";
+        cadenceEveryDays: number | null;
+        cadenceIntervals: {
+            repeatEveryDays: number;
+            whenDaysUntilDueGT?: number | null | undefined;
+            whenDaysUntilDueLT?: number | null | undefined;
+        }[] | null;
+        maxSendsInStage: number | null;
+        respectQuietHours: boolean;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    }[], Error, {
+        stageIds: string[];
+    }, unknown>;
+};
+//# sourceMappingURL=use-reminder-rule-stage-mutation.d.ts.map

package/dist/hooks/use-reminder-rule-stage-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-reminder-rule-stage-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-reminder-rule-stage-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,yCAAyC,EACzC,+BAA+B,EAC/B,yCAAyC,EAC1C,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAO5B,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAA;AACpG,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAA;AACpG,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE5F,wBAAgB,4BAA4B,CAAC,cAAc,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BpD,MAAM;eACR,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;EA+CxC"}

package/dist/hooks/use-reminder-rule-stage-mutation.js

@@ -0,0 +1,53 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantNotificationsContext } from "../provider.js";
+import { notificationsQueryKeys } from "../query-keys.js";
+import { reminderRuleStageSingleResponse, reminderRuleStagesListResponse } from "../schemas.js";
+export function useReminderRuleStageMutation(reminderRuleId) {
+    const { baseUrl, fetcher } = useVoyantNotificationsContext();
+    const queryClient = useQueryClient();
+    const base = `/v1/admin/notifications/reminder-rules/${reminderRuleId}/stages`;
+    const invalidate = () => queryClient.invalidateQueries({
+        queryKey: notificationsQueryKeys.reminderRuleStages(reminderRuleId),
+    });
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation(base, reminderRuleStageSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: () => {
+            void invalidate();
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ stageId, input, }) => {
+            const { data } = await fetchWithValidation(`${base}/${stageId}`, reminderRuleStageSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: () => {
+            void invalidate();
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (stageId) => {
+            await fetchWithValidation(`${base}/${stageId}`, 
+            // 204 → empty body; pass-through using a permissive schema
+            reminderRuleStagesListResponse.optional(), { baseUrl, fetcher }, { method: "DELETE" }).catch(() => null);
+            return stageId;
+        },
+        onSuccess: () => {
+            void invalidate();
+        },
+    });
+    const reorder = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation(`${base}/reorder`, reminderRuleStagesListResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: () => {
+            void invalidate();
+        },
+    });
+    return { create, update, remove, reorder };
+}

package/dist/hooks/use-reminder-rule-stages.d.ts

@@ -0,0 +1,25 @@
+export interface UseReminderRuleStagesOptions {
+    enabled?: boolean;
+}
+export declare function useReminderRuleStages(reminderRuleId: string, options?: UseReminderRuleStagesOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    reminderRuleId: string;
+    orderIndex: number;
+    name: string | null;
+    anchor: "due_date" | "booking_created_at" | "departure_date" | "invoice_issued_at" | "last_send_at";
+    windowStartDays: number;
+    windowEndDays: number;
+    cadenceKind: "once" | "every_n_days" | "escalating";
+    cadenceEveryDays: number | null;
+    cadenceIntervals: {
+        repeatEveryDays: number;
+        whenDaysUntilDueGT?: number | null | undefined;
+        whenDaysUntilDueLT?: number | null | undefined;
+    }[] | null;
+    maxSendsInStage: number | null;
+    respectQuietHours: boolean;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}[], Error>;
+//# sourceMappingURL=use-reminder-rule-stages.d.ts.map

package/dist/hooks/use-reminder-rule-stages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-reminder-rule-stages.d.ts","sourceRoot":"","sources":["../../src/hooks/use-reminder-rule-stages.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,4BAA4B;IAC3C,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,MAAM,EACtB,OAAO,GAAE,4BAAiC;;;;;;;;;;;;;;;;;;;;YAQ3C"}

package/dist/hooks/use-reminder-rule-stages.js

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantNotificationsContext } from "../provider.js";
+import { getReminderRuleStagesQueryOptions } from "../query-options.js";
+export function useReminderRuleStages(reminderRuleId, options = {}) {
+    const { baseUrl, fetcher } = useVoyantNotificationsContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getReminderRuleStagesQueryOptions({ baseUrl, fetcher }, reminderRuleId),
+        enabled: enabled && Boolean(reminderRuleId),
+    });
+}

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

@@ -0,0 +1,48 @@
+import type { insertNotificationReminderStageChannelSchema, updateNotificationReminderStageChannelSchema } from "@voyant-travel/notifications";
+import type { z } from "zod";
+export type CreateReminderStageChannelInput = z.input<typeof insertNotificationReminderStageChannelSchema>;
+export type UpdateReminderStageChannelInput = z.input<typeof updateNotificationReminderStageChannelSchema>;
+export declare function useReminderStageChannelMutation(reminderRuleId: string, stageId: string): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        stageId: string;
+        orderIndex: number;
+        channel: "email" | "sms";
+        provider: string | null;
+        templateId: string | null;
+        templateSlug: string | null;
+        recipientKind: "primary" | "cc" | "bcc";
+        recipientRole: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        channel: "email" | "sms";
+        orderIndex?: unknown;
+        provider?: string | null | undefined;
+        templateId?: string | null | undefined;
+        templateSlug?: string | null | undefined;
+        recipientKind?: "primary" | "cc" | "bcc" | undefined;
+        recipientRole?: string | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+    }, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        stageId: string;
+        orderIndex: number;
+        channel: "email" | "sms";
+        provider: string | null;
+        templateId: string | null;
+        templateSlug: string | null;
+        recipientKind: "primary" | "cc" | "bcc";
+        recipientRole: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        channelId: string;
+        input: UpdateReminderStageChannelInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<string, Error, string, unknown>;
+};
+//# sourceMappingURL=use-reminder-stage-channel-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-reminder-stage-channel-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-reminder-stage-channel-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,4CAA4C,EAC5C,4CAA4C,EAC7C,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAO5B,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CACnD,OAAO,4CAA4C,CACpD,CAAA;AACD,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CACnD,OAAO,4CAA4C,CACpD,CAAA;AAED,wBAAgB,+BAA+B,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA8BtE,MAAM;eACV,+BAA+B;;;EA+B3C"}

package/dist/hooks/use-reminder-stage-channel-mutation.js

@@ -0,0 +1,42 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantNotificationsContext } from "../provider.js";
+import { notificationsQueryKeys } from "../query-keys.js";
+import { reminderStageChannelSingleResponse } from "../schemas.js";
+export function useReminderStageChannelMutation(reminderRuleId, stageId) {
+    const { baseUrl, fetcher } = useVoyantNotificationsContext();
+    const queryClient = useQueryClient();
+    const base = `/v1/admin/notifications/reminder-rules/${reminderRuleId}/stages/${stageId}/channels`;
+    const invalidate = () => queryClient.invalidateQueries({
+        queryKey: notificationsQueryKeys.reminderStageChannels(stageId),
+    });
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation(base, reminderStageChannelSingleResponse, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: () => {
+            void invalidate();
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ channelId, input, }) => {
+            const { data } = await fetchWithValidation(`${base}/${channelId}`, reminderStageChannelSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: () => {
+            void invalidate();
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (channelId) => {
+            await fetchWithValidation(`${base}/${channelId}`, reminderStageChannelSingleResponse.optional(), { baseUrl, fetcher }, { method: "DELETE" }).catch(() => null);
+            return channelId;
+        },
+        onSuccess: () => {
+            void invalidate();
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-reminder-stage-channels.d.ts

@@ -0,0 +1,18 @@
+export interface UseReminderStageChannelsOptions {
+    enabled?: boolean;
+}
+export declare function useReminderStageChannels(reminderRuleId: string, stageId: string, options?: UseReminderStageChannelsOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    stageId: string;
+    orderIndex: number;
+    channel: "email" | "sms";
+    provider: string | null;
+    templateId: string | null;
+    templateSlug: string | null;
+    recipientKind: "primary" | "cc" | "bcc";
+    recipientRole: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}[], Error>;
+//# sourceMappingURL=use-reminder-stage-channels.d.ts.map

package/dist/hooks/use-reminder-stage-channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-reminder-stage-channels.d.ts","sourceRoot":"","sources":["../../src/hooks/use-reminder-stage-channels.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,+BAA+B;IAC9C,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,+BAAoC;;;;;;;;;;;;;YAQ9C"}

package/dist/hooks/use-reminder-stage-channels.js

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantNotificationsContext } from "../provider.js";
+import { getReminderStageChannelsQueryOptions } from "../query-options.js";
+export function useReminderStageChannels(reminderRuleId, stageId, options = {}) {
+    const { baseUrl, fetcher } = useVoyantNotificationsContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getReminderStageChannelsQueryOptions({ baseUrl, fetcher }, reminderRuleId, stageId),
+        enabled: enabled && Boolean(reminderRuleId) && Boolean(stageId),
+    });
+}

package/dist/hooks/use-reminders-preview.d.ts

@@ -0,0 +1,21 @@
+import type { RemindersPreviewFilters } from "../query-keys.js";
+export interface UseRemindersPreviewOptions extends RemindersPreviewFilters {
+    enabled?: boolean;
+}
+export declare function useRemindersPreview(options?: UseRemindersPreviewOptions): import("@tanstack/react-query").UseQueryResult<{
+    ruleId: string;
+    ruleName: string;
+    ruleSlug: string;
+    targetType: string;
+    targetId: string;
+    bookingId: string | null;
+    stageId: string;
+    stageName: string | null;
+    stageOrderIndex: number;
+    anchor: string;
+    anchorDate: string;
+    scheduledAt: string;
+    sendCountAtFire: number;
+    reasoning: string;
+}[], Error>;
+//# sourceMappingURL=use-reminders-preview.d.ts.map

package/dist/hooks/use-reminders-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-reminders-preview.d.ts","sourceRoot":"","sources":["../../src/hooks/use-reminders-preview.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAA;AAG/D,MAAM,WAAW,0BAA2B,SAAQ,uBAAuB;IACzE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,0BAA+B;;;;;;;;;;;;;;;YAO3E"}

package/dist/hooks/use-reminders-preview.js

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