@tbs-fitness/contract 0.3.0 → 0.4.0

package/README.md

@@ -41,6 +41,17 @@ const result = createFlagSchema.safeParse(input); // The same rules as the API.
 
 Requests have two types. Clients use `*Input`, where fields with a default are optional. The backend uses `*Body`, which is the result after validation. List queries come from the URL as strings, so they have no `*Input`: use `Partial<PaginationQuery>` or `Partial<AuditLogQuery>`.
 
+## Version 0.4.0
+
+Communication and runtime settings. Additive; consumers install `^0.4.0` explicitly.
+
+- `/enums`: `COMMUNICATION_CHANNELS` (`EMAIL`, `SMS`), `MESSAGE_TYPES`, `DELIVERY_STATUSES` and `TEMPLATE_STATUSES`.
+- New `/communication`:
+  - `MESSAGE_CATALOGUE`: per message type, the channels that may carry it, the default switches, and the variables its sender supplies, with the required ones.
+  - `templatePlaceholders`, `hasMalformedPlaceholder` and `templateProblems`, the template rules shared by the server and the admin editor.
+  - `createTemplateSchema`, `templateResponseSchema`, `previewTemplateSchema`, `renderedMessageSchema`, `testSendResponseSchema` and `messageTypeResponseSchema`.
+- New `/app-settings`: `APP_SETTING_KEYS`, a value schema and default per key (`communication.channels` master switches, `communication.messages` per type and channel), plus `appSettingResponseSchema`, `updateAppSettingSchema` (`{ value, version }`) and `appSettingHistoryResponseSchema`.
+
 ## Version 0.3.0
 
 Time zones and the platform's date and time rules. Additive, but a caret range on 0.x does not cross minor versions, so consumers install `^0.3.0` explicitly.

package/dist/cjs/app-settings/app-settings.dto.d.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { type MessageType } from '../enums/index.js';
+/**
+ * Runtime settings an administrator changes without a deploy. Each key has a
+ * value schema here, which both the server and the admin screen use. A key
+ * with no saved value uses its default.
+ */
+export declare const APP_SETTING_KEYS: readonly ["communication.channels", "communication.messages"];
+export type AppSettingKey = (typeof APP_SETTING_KEYS)[number];
+/** A switch per channel. */
+export declare const channelSwitchesSchema: z.ZodObject<{
+    EMAIL: z.ZodBoolean;
+    SMS: z.ZodBoolean;
+}, z.core.$strict>;
+export type ChannelSwitches = z.output<typeof channelSwitchesSchema>;
+/**
+ * Master switches: a channel switched off here sends nothing, whatever the
+ * per-message settings say.
+ */
+export declare const communicationChannelsSettingSchema: z.ZodObject<{
+    EMAIL: z.ZodBoolean;
+    SMS: z.ZodBoolean;
+}, z.core.$strict>;
+/**
+ * Per message type and channel. A type missing from a saved value uses its
+ * catalogue defaults, so a newly added message type needs no data change.
+ */
+export declare const communicationMessagesSettingSchema: z.ZodRecord<z.ZodEnum<{
+    "auth.otp.signup_verification": "auth.otp.signup_verification";
+    "auth.otp.password_reset": "auth.otp.password_reset";
+    "auth.password_reset_link": "auth.password_reset_link";
+}> & z.core.$partial, z.ZodObject<{
+    EMAIL: z.ZodBoolean;
+    SMS: z.ZodBoolean;
+}, z.core.$strict>>;
+export type CommunicationMessagesSetting = z.output<typeof communicationMessagesSettingSchema>;
+export declare const APP_SETTING_VALUE_SCHEMAS: {
+    readonly 'communication.channels': z.ZodObject<{
+        EMAIL: z.ZodBoolean;
+        SMS: z.ZodBoolean;
+    }, z.core.$strict>;
+    readonly 'communication.messages': z.ZodRecord<z.ZodEnum<{
+        "auth.otp.signup_verification": "auth.otp.signup_verification";
+        "auth.otp.password_reset": "auth.otp.password_reset";
+        "auth.password_reset_link": "auth.password_reset_link";
+    }> & z.core.$partial, z.ZodObject<{
+        EMAIL: z.ZodBoolean;
+        SMS: z.ZodBoolean;
+    }, z.core.$strict>>;
+};
+export interface AppSettingValues {
+    'communication.channels': ChannelSwitches;
+    'communication.messages': CommunicationMessagesSetting;
+}
+/** Every message type, with its catalogue defaults: the effective value with nothing saved. */
+export declare function defaultMessageSettings(): Record<MessageType, ChannelSwitches>;
+export declare const APP_SETTING_DEFAULTS: AppSettingValues;
+export declare const appSettingKeyParamSchema: z.ZodEnum<{
+    "communication.channels": "communication.channels";
+    "communication.messages": "communication.messages";
+}>;
+export declare const appSettingResponseSchema: z.ZodObject<{
+    key: z.ZodEnum<{
+        "communication.channels": "communication.channels";
+        "communication.messages": "communication.messages";
+    }>;
+    label: z.ZodString;
+    description: z.ZodString;
+    value: z.ZodUnknown;
+    defaultValue: z.ZodUnknown;
+    version: z.ZodNumber;
+    updatedBy: z.ZodNullable<z.ZodUUID>;
+    updatedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type AppSettingResponse = z.output<typeof appSettingResponseSchema>;
+export declare const appSettingListResponseSchema: z.ZodArray<z.ZodObject<{
+    key: z.ZodEnum<{
+        "communication.channels": "communication.channels";
+        "communication.messages": "communication.messages";
+    }>;
+    label: z.ZodString;
+    description: z.ZodString;
+    value: z.ZodUnknown;
+    defaultValue: z.ZodUnknown;
+    version: z.ZodNumber;
+    updatedBy: z.ZodNullable<z.ZodUUID>;
+    updatedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>>;
+/**
+ * Replaces a setting's value. `version` must be the one last read, so a
+ * change made in between is not silently overwritten. The value is checked
+ * against the key's schema on the server.
+ */
+export declare const updateAppSettingSchema: z.ZodObject<{
+    value: z.ZodUnknown;
+    version: z.ZodNumber;
+}, z.core.$strict>;
+export type UpdateAppSettingInput = z.input<typeof updateAppSettingSchema>;
+export type UpdateAppSettingBody = z.output<typeof updateAppSettingSchema>;
+export declare const appSettingHistoryEntrySchema: z.ZodObject<{
+    id: z.ZodUUID;
+    key: z.ZodEnum<{
+        "communication.channels": "communication.channels";
+        "communication.messages": "communication.messages";
+    }>;
+    previousValue: z.ZodUnknown;
+    newValue: z.ZodUnknown;
+    version: z.ZodNumber;
+    actorUserId: z.ZodUUID;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type AppSettingHistoryEntry = z.output<typeof appSettingHistoryEntrySchema>;
+export declare const appSettingHistoryResponseSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodUUID;
+    key: z.ZodEnum<{
+        "communication.channels": "communication.channels";
+        "communication.messages": "communication.messages";
+    }>;
+    previousValue: z.ZodUnknown;
+    newValue: z.ZodUnknown;
+    version: z.ZodNumber;
+    actorUserId: z.ZodUUID;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>>;

package/dist/cjs/app-settings/app-settings.dto.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appSettingHistoryResponseSchema = exports.appSettingHistoryEntrySchema = exports.updateAppSettingSchema = exports.appSettingListResponseSchema = exports.appSettingResponseSchema = exports.appSettingKeyParamSchema = exports.APP_SETTING_DEFAULTS = exports.APP_SETTING_VALUE_SCHEMAS = exports.communicationMessagesSettingSchema = exports.communicationChannelsSettingSchema = exports.channelSwitchesSchema = exports.APP_SETTING_KEYS = void 0;
+exports.defaultMessageSettings = defaultMessageSettings;
+const zod_1 = require("zod");
+const date_time_schema_js_1 = require("../common/date-time.schema.js");
+const message_catalogue_js_1 = require("../communication/message-catalogue.js");
+const index_js_1 = require("../enums/index.js");
+/**
+ * Runtime settings an administrator changes without a deploy. Each key has a
+ * value schema here, which both the server and the admin screen use. A key
+ * with no saved value uses its default.
+ */
+exports.APP_SETTING_KEYS = [
+    'communication.channels',
+    'communication.messages',
+];
+/** A switch per channel. */
+exports.channelSwitchesSchema = zod_1.z.strictObject({
+    EMAIL: zod_1.z.boolean(),
+    SMS: zod_1.z.boolean(),
+});
+/**
+ * Master switches: a channel switched off here sends nothing, whatever the
+ * per-message settings say.
+ */
+exports.communicationChannelsSettingSchema = exports.channelSwitchesSchema;
+/**
+ * Per message type and channel. A type missing from a saved value uses its
+ * catalogue defaults, so a newly added message type needs no data change.
+ */
+exports.communicationMessagesSettingSchema = zod_1.z
+    .partialRecord(zod_1.z.enum(index_js_1.MESSAGE_TYPES), exports.channelSwitchesSchema)
+    .superRefine((value, ctx) => {
+    for (const [type, switches] of Object.entries(value)) {
+        const allowed = message_catalogue_js_1.MESSAGE_CATALOGUE[type].channels;
+        for (const [channel, on] of Object.entries(switches ?? {})) {
+            if (on && !allowed.includes(channel)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: [type, channel],
+                    message: `${message_catalogue_js_1.MESSAGE_CATALOGUE[type].label} cannot be sent by ${channel}`,
+                });
+            }
+        }
+    }
+});
+exports.APP_SETTING_VALUE_SCHEMAS = {
+    'communication.channels': exports.communicationChannelsSettingSchema,
+    'communication.messages': exports.communicationMessagesSettingSchema,
+};
+/** Every message type, with its catalogue defaults: the effective value with nothing saved. */
+function defaultMessageSettings() {
+    return Object.fromEntries(index_js_1.MESSAGE_TYPES.map((type) => [
+        type,
+        { ...message_catalogue_js_1.MESSAGE_CATALOGUE[type].defaultChannels },
+    ]));
+}
+exports.APP_SETTING_DEFAULTS = {
+    'communication.channels': { EMAIL: true, SMS: true },
+    'communication.messages': defaultMessageSettings(),
+};
+exports.appSettingKeyParamSchema = zod_1.z.enum(exports.APP_SETTING_KEYS);
+exports.appSettingResponseSchema = zod_1.z.object({
+    key: zod_1.z.enum(exports.APP_SETTING_KEYS),
+    label: zod_1.z.string(),
+    description: zod_1.z.string(),
+    value: zod_1.z.unknown(),
+    defaultValue: zod_1.z.unknown(),
+    /** 0 until the setting is first saved. Send it back to update. */
+    version: zod_1.z.number().int(),
+    updatedBy: zod_1.z.uuid().nullable(),
+    updatedAt: date_time_schema_js_1.utcTimestampSchema.nullable(),
+});
+exports.appSettingListResponseSchema = zod_1.z.array(exports.appSettingResponseSchema);
+/**
+ * Replaces a setting's value. `version` must be the one last read, so a
+ * change made in between is not silently overwritten. The value is checked
+ * against the key's schema on the server.
+ */
+exports.updateAppSettingSchema = zod_1.z.strictObject({
+    value: zod_1.z.unknown(),
+    version: zod_1.z.number().int().min(0),
+});
+exports.appSettingHistoryEntrySchema = zod_1.z.object({
+    id: zod_1.z.uuid(),
+    key: zod_1.z.enum(exports.APP_SETTING_KEYS),
+    previousValue: zod_1.z.unknown(),
+    newValue: zod_1.z.unknown(),
+    version: zod_1.z.number().int(),
+    actorUserId: zod_1.z.uuid(),
+    createdAt: date_time_schema_js_1.utcTimestampSchema,
+});
+exports.appSettingHistoryResponseSchema = zod_1.z.array(exports.appSettingHistoryEntrySchema);

package/dist/cjs/app-settings/index.d.ts

@@ -0,0 +1 @@
+export * from './app-settings.dto.js';

package/dist/cjs/app-settings/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./app-settings.dto.js"), exports);

package/dist/cjs/communication/index.d.ts

@@ -0,0 +1,2 @@
+export * from './message-catalogue.js';
+export * from './template.dto.js';

package/dist/cjs/communication/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./message-catalogue.js"), exports);
+__exportStar(require("./template.dto.js"), exports);

package/dist/cjs/communication/message-catalogue.d.ts

@@ -0,0 +1,26 @@
+import type { CommunicationChannel, MessageType } from '../enums/index.js';
+/**
+ * What the platform knows about each message type: the channels that may carry
+ * it, the channels switched on by default, and the variables its sender
+ * supplies. A template may only use supplied variables, and must use the
+ * required ones, so an admin can never activate a template the system cannot
+ * fill.
+ */
+export interface MessageTypeDefinition {
+    label: string;
+    description: string;
+    channels: readonly CommunicationChannel[];
+    defaultChannels: Readonly<Record<CommunicationChannel, boolean>>;
+    /** Every variable the sender passes, with a sample value for previews. */
+    variables: Readonly<Record<string, {
+        description: string;
+        example: string;
+    }>>;
+    /** Variables every template for this type must use. */
+    requiredVariables: readonly string[];
+}
+export declare const MESSAGE_CATALOGUE: Readonly<Record<MessageType, MessageTypeDefinition>>;
+/** The longest SMS body a template may have: four concatenated GSM-7 segments. */
+export declare const MAX_SMS_LENGTH = 612;
+/** One GSM-7 segment. Longer messages are split and cost more. */
+export declare const SMS_SEGMENT_LENGTH = 160;

package/dist/cjs/communication/message-catalogue.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMS_SEGMENT_LENGTH = exports.MAX_SMS_LENGTH = exports.MESSAGE_CATALOGUE = void 0;
+const OTP_VARIABLES = {
+    code: { description: 'The one-time code', example: '482915' },
+    fullName: { description: "The recipient's name", example: 'Biki Singh' },
+    expiresInMinutes: {
+        description: 'Minutes until the code expires',
+        example: '10',
+    },
+    appName: { description: 'The product name', example: 'TBS' },
+};
+exports.MESSAGE_CATALOGUE = {
+    'auth.otp.signup_verification': {
+        label: 'Sign-up verification code',
+        description: 'Sent when a coach signs up, to verify their email address.',
+        channels: ['EMAIL', 'SMS'],
+        defaultChannels: { EMAIL: true, SMS: false },
+        variables: OTP_VARIABLES,
+        requiredVariables: ['code'],
+    },
+    'auth.otp.password_reset': {
+        label: 'Password recovery code',
+        description: 'Sent when a coach asks to reset a forgotten password.',
+        channels: ['EMAIL', 'SMS'],
+        defaultChannels: { EMAIL: true, SMS: false },
+        variables: OTP_VARIABLES,
+        requiredVariables: ['code'],
+    },
+    'auth.password_reset_link': {
+        label: 'Password reset link',
+        description: 'Sent when an administrator account requests a reset link.',
+        channels: ['EMAIL'],
+        defaultChannels: { EMAIL: true, SMS: false },
+        variables: {
+            resetUrl: {
+                description: 'The single-use reset link',
+                example: 'https://app.example.com/reset-password?token=…',
+            },
+            fullName: { description: "The recipient's name", example: 'Biki Singh' },
+            expiresInMinutes: {
+                description: 'Minutes until the link expires',
+                example: '30',
+            },
+            appName: { description: 'The product name', example: 'TBS' },
+        },
+        requiredVariables: ['resetUrl'],
+    },
+};
+/** The longest SMS body a template may have: four concatenated GSM-7 segments. */
+exports.MAX_SMS_LENGTH = 612;
+/** One GSM-7 segment. Longer messages are split and cost more. */
+exports.SMS_SEGMENT_LENGTH = 160;

package/dist/cjs/communication/template.dto.d.ts

@@ -0,0 +1,240 @@
+import { z } from 'zod';
+import { type CommunicationChannel, type MessageType } from '../enums/index.js';
+/** The variable names used as `{{name}}` in a piece of template text, in order, without repeats. */
+export declare function templatePlaceholders(text: string): string[];
+/** True when the text has a `{{` or `}}` that is not part of a valid placeholder. */
+export declare function hasMalformedPlaceholder(text: string): boolean;
+/** A variable a template declares. Its value is supplied when the message is sent. */
+export declare const templateVariableSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    example: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TemplateVariable = z.output<typeof templateVariableSchema>;
+interface TemplateShape {
+    messageType: MessageType;
+    channel: CommunicationChannel;
+    subject?: string | null | undefined;
+    bodyText: string;
+    bodyHtml?: string | null | undefined;
+    variables: {
+        name: string;
+    }[];
+}
+/**
+ * The rules every template must meet before it is saved: the declared
+ * variables match the placeholders exactly, every one is supplied by the
+ * message type, and the type's required variables are used. Shared by the
+ * server and the admin editor, so both report the same problems.
+ */
+export declare function templateProblems(template: TemplateShape): {
+    path: string;
+    message: string;
+}[];
+/** A new draft. Saved templates are never edited; a change is a new version. */
+export declare const createTemplateSchema: z.ZodObject<{
+    messageType: z.ZodEnum<{
+        "auth.otp.signup_verification": "auth.otp.signup_verification";
+        "auth.otp.password_reset": "auth.otp.password_reset";
+        "auth.password_reset_link": "auth.password_reset_link";
+    }>;
+    channel: z.ZodEnum<{
+        EMAIL: "EMAIL";
+        SMS: "SMS";
+    }>;
+    name: z.ZodPipe<z.ZodString, z.ZodString>;
+    subject: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    bodyText: z.ZodString;
+    bodyHtml: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    variables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        example: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CreateTemplateInput = z.input<typeof createTemplateSchema>;
+export type CreateTemplateBody = z.output<typeof createTemplateSchema>;
+export declare const templateListQuerySchema: z.ZodObject<{
+    messageType: z.ZodOptional<z.ZodEnum<{
+        "auth.otp.signup_verification": "auth.otp.signup_verification";
+        "auth.otp.password_reset": "auth.otp.password_reset";
+        "auth.password_reset_link": "auth.password_reset_link";
+    }>>;
+    channel: z.ZodOptional<z.ZodEnum<{
+        EMAIL: "EMAIL";
+        SMS: "SMS";
+    }>>;
+}, z.core.$strict>;
+export type TemplateListQuery = z.output<typeof templateListQuerySchema>;
+export declare const templateResponseSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    messageType: z.ZodEnum<{
+        "auth.otp.signup_verification": "auth.otp.signup_verification";
+        "auth.otp.password_reset": "auth.otp.password_reset";
+        "auth.password_reset_link": "auth.password_reset_link";
+    }>;
+    channel: z.ZodEnum<{
+        EMAIL: "EMAIL";
+        SMS: "SMS";
+    }>;
+    version: z.ZodNumber;
+    name: z.ZodString;
+    subject: z.ZodNullable<z.ZodString>;
+    bodyText: z.ZodString;
+    bodyHtml: z.ZodNullable<z.ZodString>;
+    variables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        example: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        active: "active";
+        draft: "draft";
+        archived: "archived";
+    }>;
+    createdBy: z.ZodNullable<z.ZodUUID>;
+    createdAt: z.ZodISODateTime;
+    activatedBy: z.ZodNullable<z.ZodUUID>;
+    activatedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type TemplateResponse = z.output<typeof templateResponseSchema>;
+export declare const templateListResponseSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodUUID;
+    messageType: z.ZodEnum<{
+        "auth.otp.signup_verification": "auth.otp.signup_verification";
+        "auth.otp.password_reset": "auth.otp.password_reset";
+        "auth.password_reset_link": "auth.password_reset_link";
+    }>;
+    channel: z.ZodEnum<{
+        EMAIL: "EMAIL";
+        SMS: "SMS";
+    }>;
+    version: z.ZodNumber;
+    name: z.ZodString;
+    subject: z.ZodNullable<z.ZodString>;
+    bodyText: z.ZodString;
+    bodyHtml: z.ZodNullable<z.ZodString>;
+    variables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        example: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        active: "active";
+        draft: "draft";
+        archived: "archived";
+    }>;
+    createdBy: z.ZodNullable<z.ZodUUID>;
+    createdAt: z.ZodISODateTime;
+    activatedBy: z.ZodNullable<z.ZodUUID>;
+    activatedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>>;
+/** Renders unsaved text, or a saved version, with the catalogue's sample values. */
+export declare const previewTemplateSchema: z.ZodUnion<readonly [z.ZodObject<{
+    templateId: z.ZodUUID;
+}, z.core.$strict>, z.ZodObject<{
+    messageType: z.ZodEnum<{
+        "auth.otp.signup_verification": "auth.otp.signup_verification";
+        "auth.otp.password_reset": "auth.otp.password_reset";
+        "auth.password_reset_link": "auth.password_reset_link";
+    }>;
+    channel: z.ZodEnum<{
+        EMAIL: "EMAIL";
+        SMS: "SMS";
+    }>;
+    name: z.ZodPipe<z.ZodString, z.ZodString>;
+    subject: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    bodyText: z.ZodString;
+    bodyHtml: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    variables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        example: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>]>;
+export type PreviewTemplateInput = z.input<typeof previewTemplateSchema>;
+export type PreviewTemplateBody = z.output<typeof previewTemplateSchema>;
+export declare const renderedMessageSchema: z.ZodObject<{
+    channel: z.ZodEnum<{
+        EMAIL: "EMAIL";
+        SMS: "SMS";
+    }>;
+    subject: z.ZodNullable<z.ZodString>;
+    bodyText: z.ZodString;
+    bodyHtml: z.ZodNullable<z.ZodString>;
+    smsSegments: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type RenderedMessage = z.output<typeof renderedMessageSchema>;
+export declare const testSendResponseSchema: z.ZodObject<{
+    channel: z.ZodEnum<{
+        EMAIL: "EMAIL";
+        SMS: "SMS";
+    }>;
+    sentTo: z.ZodString;
+}, z.core.$strip>;
+export type TestSendResponse = z.output<typeof testSendResponseSchema>;
+/** A catalogue entry, with the built-in default template for each channel. */
+export declare const messageTypeResponseSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        "auth.otp.signup_verification": "auth.otp.signup_verification";
+        "auth.otp.password_reset": "auth.otp.password_reset";
+        "auth.password_reset_link": "auth.password_reset_link";
+    }>;
+    label: z.ZodString;
+    description: z.ZodString;
+    channels: z.ZodArray<z.ZodEnum<{
+        EMAIL: "EMAIL";
+        SMS: "SMS";
+    }>>;
+    variables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        example: z.ZodString;
+    }, z.core.$strip>>;
+    requiredVariables: z.ZodArray<z.ZodString>;
+    defaults: z.ZodArray<z.ZodObject<{
+        channel: z.ZodEnum<{
+            EMAIL: "EMAIL";
+            SMS: "SMS";
+        }>;
+        subject: z.ZodNullable<z.ZodString>;
+        bodyText: z.ZodString;
+        bodyHtml: z.ZodNullable<z.ZodString>;
+        variables: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MessageTypeResponse = z.output<typeof messageTypeResponseSchema>;
+export declare const messageTypeListResponseSchema: z.ZodArray<z.ZodObject<{
+    type: z.ZodEnum<{
+        "auth.otp.signup_verification": "auth.otp.signup_verification";
+        "auth.otp.password_reset": "auth.otp.password_reset";
+        "auth.password_reset_link": "auth.password_reset_link";
+    }>;
+    label: z.ZodString;
+    description: z.ZodString;
+    channels: z.ZodArray<z.ZodEnum<{
+        EMAIL: "EMAIL";
+        SMS: "SMS";
+    }>>;
+    variables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        example: z.ZodString;
+    }, z.core.$strip>>;
+    requiredVariables: z.ZodArray<z.ZodString>;
+    defaults: z.ZodArray<z.ZodObject<{
+        channel: z.ZodEnum<{
+            EMAIL: "EMAIL";
+            SMS: "SMS";
+        }>;
+        subject: z.ZodNullable<z.ZodString>;
+        bodyText: z.ZodString;
+        bodyHtml: z.ZodNullable<z.ZodString>;
+        variables: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export {};