@tbs-fitness/contract 0.3.0 → 0.4.0

package/dist/cjs/communication/template.dto.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messageTypeListResponseSchema = exports.messageTypeResponseSchema = exports.testSendResponseSchema = exports.renderedMessageSchema = exports.previewTemplateSchema = exports.templateListResponseSchema = exports.templateResponseSchema = exports.templateListQuerySchema = exports.createTemplateSchema = exports.templateVariableSchema = void 0;
+exports.templatePlaceholders = templatePlaceholders;
+exports.hasMalformedPlaceholder = hasMalformedPlaceholder;
+exports.templateProblems = templateProblems;
+const zod_1 = require("zod");
+const date_time_schema_js_1 = require("../common/date-time.schema.js");
+const safe_text_schema_js_1 = require("../common/safe-text.schema.js");
+const index_js_1 = require("../enums/index.js");
+const message_catalogue_js_1 = require("./message-catalogue.js");
+const PLACEHOLDER = /\{\{\s*([A-Za-z][A-Za-z0-9_]*)\s*\}\}/g;
+/** The variable names used as `{{name}}` in a piece of template text, in order, without repeats. */
+function templatePlaceholders(text) {
+    const names = new Set();
+    for (const match of text.matchAll(PLACEHOLDER)) {
+        names.add(match[1]);
+    }
+    return [...names];
+}
+/** True when the text has a `{{` or `}}` that is not part of a valid placeholder. */
+function hasMalformedPlaceholder(text) {
+    const rest = text.replace(PLACEHOLDER, '');
+    return rest.includes('{{') || rest.includes('}}');
+}
+const MAX_SUBJECT_LENGTH = 200;
+const MAX_BODY_LENGTH = 20000;
+/** A variable a template declares. Its value is supplied when the message is sent. */
+exports.templateVariableSchema = zod_1.z.strictObject({
+    name: zod_1.z
+        .string()
+        .regex(/^[A-Za-z][A-Za-z0-9_]*$/, {
+        error: 'Use letters, digits and underscores, starting with a letter',
+    })
+        .max(64),
+    description: (0, safe_text_schema_js_1.safeTextSchema)(200).optional(),
+    example: zod_1.z.string().max(500).optional(),
+});
+const templateFields = {
+    messageType: zod_1.z.enum(index_js_1.MESSAGE_TYPES),
+    channel: zod_1.z.enum(index_js_1.COMMUNICATION_CHANNELS),
+    name: (0, safe_text_schema_js_1.safeTextSchema)(100).pipe(zod_1.z.string().min(1, { error: 'Name it' })),
+    subject: zod_1.z.string().max(MAX_SUBJECT_LENGTH).nullish(),
+    bodyText: zod_1.z
+        .string()
+        .min(1, { error: 'Write the message' })
+        .max(MAX_BODY_LENGTH),
+    bodyHtml: zod_1.z.string().max(MAX_BODY_LENGTH).nullish(),
+    variables: zod_1.z.array(exports.templateVariableSchema).max(20),
+};
+/**
+ * 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.
+ */
+function templateProblems(template) {
+    const problems = [];
+    const definition = message_catalogue_js_1.MESSAGE_CATALOGUE[template.messageType];
+    const isEmail = template.channel === 'EMAIL';
+    if (!definition.channels.includes(template.channel)) {
+        problems.push({
+            path: 'channel',
+            message: `${definition.label} cannot be sent by ${template.channel}`,
+        });
+    }
+    if (isEmail && !template.subject?.trim()) {
+        problems.push({ path: 'subject', message: 'An email needs a subject' });
+    }
+    if (!isEmail && (template.subject || template.bodyHtml)) {
+        problems.push({
+            path: 'bodyHtml',
+            message: 'Only email templates have a subject or HTML',
+        });
+    }
+    if (template.channel === 'SMS' && template.bodyText.length > message_catalogue_js_1.MAX_SMS_LENGTH) {
+        problems.push({
+            path: 'bodyText',
+            message: `An SMS can be at most ${String(message_catalogue_js_1.MAX_SMS_LENGTH)} characters`,
+        });
+    }
+    const texts = [
+        template.subject ?? '',
+        template.bodyText,
+        template.bodyHtml ?? '',
+    ];
+    if (texts.some(hasMalformedPlaceholder)) {
+        problems.push({
+            path: 'bodyText',
+            message: 'Write placeholders as {{name}}, with matching braces',
+        });
+    }
+    const used = new Set(texts.flatMap(templatePlaceholders));
+    const declared = template.variables.map((variable) => variable.name);
+    const declaredSet = new Set(declared);
+    if (declaredSet.size !== declared.length) {
+        problems.push({ path: 'variables', message: 'Declare each variable once' });
+    }
+    for (const name of used) {
+        if (!declaredSet.has(name)) {
+            problems.push({
+                path: 'variables',
+                message: `{{${name}}} is used but not declared`,
+            });
+        }
+    }
+    for (const name of declaredSet) {
+        if (!used.has(name)) {
+            problems.push({
+                path: 'variables',
+                message: `${name} is declared but not used`,
+            });
+        }
+        if (!(name in definition.variables)) {
+            problems.push({
+                path: 'variables',
+                message: `${definition.label} does not supply ${name}`,
+            });
+        }
+    }
+    for (const name of definition.requiredVariables) {
+        if (!declaredSet.has(name)) {
+            problems.push({
+                path: 'variables',
+                message: `${definition.label} must include {{${name}}}`,
+            });
+        }
+    }
+    return problems;
+}
+/** A new draft. Saved templates are never edited; a change is a new version. */
+exports.createTemplateSchema = zod_1.z
+    .strictObject(templateFields)
+    .superRefine((template, ctx) => {
+    for (const problem of templateProblems(template)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: [problem.path],
+            message: problem.message,
+        });
+    }
+});
+exports.templateListQuerySchema = zod_1.z.strictObject({
+    messageType: zod_1.z.enum(index_js_1.MESSAGE_TYPES).optional(),
+    channel: zod_1.z.enum(index_js_1.COMMUNICATION_CHANNELS).optional(),
+});
+exports.templateResponseSchema = zod_1.z.object({
+    id: zod_1.z.uuid(),
+    messageType: zod_1.z.enum(index_js_1.MESSAGE_TYPES),
+    channel: zod_1.z.enum(index_js_1.COMMUNICATION_CHANNELS),
+    version: zod_1.z.number().int(),
+    name: zod_1.z.string(),
+    subject: zod_1.z.string().nullable(),
+    bodyText: zod_1.z.string(),
+    bodyHtml: zod_1.z.string().nullable(),
+    variables: zod_1.z.array(zod_1.z.object({
+        name: zod_1.z.string(),
+        description: zod_1.z.string().optional(),
+        example: zod_1.z.string().optional(),
+    })),
+    status: zod_1.z.enum(index_js_1.TEMPLATE_STATUSES),
+    createdBy: zod_1.z.uuid().nullable(),
+    createdAt: date_time_schema_js_1.utcTimestampSchema,
+    activatedBy: zod_1.z.uuid().nullable(),
+    activatedAt: date_time_schema_js_1.utcTimestampSchema.nullable(),
+});
+exports.templateListResponseSchema = zod_1.z.array(exports.templateResponseSchema);
+/** Renders unsaved text, or a saved version, with the catalogue's sample values. */
+exports.previewTemplateSchema = zod_1.z.union([
+    zod_1.z.strictObject({ templateId: zod_1.z.uuid() }),
+    zod_1.z.strictObject(templateFields),
+]);
+exports.renderedMessageSchema = zod_1.z.object({
+    channel: zod_1.z.enum(index_js_1.COMMUNICATION_CHANNELS),
+    subject: zod_1.z.string().nullable(),
+    bodyText: zod_1.z.string(),
+    bodyHtml: zod_1.z.string().nullable(),
+    /** SMS only: how many 160-character segments it takes. */
+    smsSegments: zod_1.z.number().int().nullable(),
+});
+exports.testSendResponseSchema = zod_1.z.object({
+    channel: zod_1.z.enum(index_js_1.COMMUNICATION_CHANNELS),
+    /** The signed-in admin's own address, masked, such as `b***@tbs.coach`. */
+    sentTo: zod_1.z.string(),
+});
+/** A catalogue entry, with the built-in default template for each channel. */
+exports.messageTypeResponseSchema = zod_1.z.object({
+    type: zod_1.z.enum(index_js_1.MESSAGE_TYPES),
+    label: zod_1.z.string(),
+    description: zod_1.z.string(),
+    channels: zod_1.z.array(zod_1.z.enum(index_js_1.COMMUNICATION_CHANNELS)),
+    variables: zod_1.z.array(zod_1.z.object({
+        name: zod_1.z.string(),
+        description: zod_1.z.string(),
+        example: zod_1.z.string(),
+    })),
+    requiredVariables: zod_1.z.array(zod_1.z.string()),
+    defaults: zod_1.z.array(zod_1.z.object({
+        channel: zod_1.z.enum(index_js_1.COMMUNICATION_CHANNELS),
+        subject: zod_1.z.string().nullable(),
+        bodyText: zod_1.z.string(),
+        bodyHtml: zod_1.z.string().nullable(),
+        variables: zod_1.z.array(zod_1.z.object({ name: zod_1.z.string() })),
+    })),
+});
+exports.messageTypeListResponseSchema = zod_1.z.array(exports.messageTypeResponseSchema);

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

@@ -25,3 +25,22 @@ export declare const AUDIT_OUTCOMES: readonly ["success", "failure"];
 export type AuditOutcome = (typeof AUDIT_OUTCOMES)[number];
 export declare const FEATURE_FLAG_RULE_TYPES: readonly ["user", "customer", "trainer", "role"];
 export type FeatureFlagRuleType = (typeof FEATURE_FLAG_RULE_TYPES)[number];
+/**
+ * The ways a message can reach someone. WhatsApp and push are added here when
+ * their channel modules are built.
+ */
+export declare const COMMUNICATION_CHANNELS: readonly ["EMAIL", "SMS"];
+export type CommunicationChannel = (typeof COMMUNICATION_CHANNELS)[number];
+/**
+ * Every message the platform sends. Each has a catalogue entry in
+ * `@tbs-fitness/contract/communication` saying which channels may carry it and
+ * which variables its sender supplies.
+ */
+export declare const MESSAGE_TYPES: readonly ["auth.otp.signup_verification", "auth.otp.password_reset", "auth.password_reset_link"];
+export type MessageType = (typeof MESSAGE_TYPES)[number];
+/** What happened to one message on one channel. */
+export declare const DELIVERY_STATUSES: readonly ["sent", "skipped_disabled", "skipped_unreachable", "failed", "failed_missing_variables"];
+export type DeliveryStatus = (typeof DELIVERY_STATUSES)[number];
+/** Only one version of a template per message type and channel is active. */
+export declare const TEMPLATE_STATUSES: readonly ["draft", "active", "archived"];
+export type TemplateStatus = (typeof TEMPLATE_STATUSES)[number];

package/dist/cjs/enums/index.js

@@ -2,7 +2,7 @@
 // These values are stored in the database and sent over the API. Renaming or
 // removing one is a breaking change, so it needs a major version.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FEATURE_FLAG_RULE_TYPES = exports.AUDIT_OUTCOMES = exports.TOKEN_TRANSPORTS = exports.TIMEZONE_SOURCES = exports.ADMIN_SETTABLE_ACCOUNT_STATUSES = exports.ACCOUNT_STATUSES = exports.ROLES = exports.APP_ENVIRONMENTS = void 0;
+exports.TEMPLATE_STATUSES = exports.DELIVERY_STATUSES = exports.MESSAGE_TYPES = exports.COMMUNICATION_CHANNELS = exports.FEATURE_FLAG_RULE_TYPES = exports.AUDIT_OUTCOMES = exports.TOKEN_TRANSPORTS = exports.TIMEZONE_SOURCES = exports.ADMIN_SETTABLE_ACCOUNT_STATUSES = exports.ACCOUNT_STATUSES = exports.ROLES = exports.APP_ENVIRONMENTS = void 0;
 exports.APP_ENVIRONMENTS = [
     'development',
     'staging',
@@ -35,3 +35,28 @@ exports.FEATURE_FLAG_RULE_TYPES = [
     'trainer',
     'role',
 ];
+/**
+ * The ways a message can reach someone. WhatsApp and push are added here when
+ * their channel modules are built.
+ */
+exports.COMMUNICATION_CHANNELS = ['EMAIL', 'SMS'];
+/**
+ * Every message the platform sends. Each has a catalogue entry in
+ * `@tbs-fitness/contract/communication` saying which channels may carry it and
+ * which variables its sender supplies.
+ */
+exports.MESSAGE_TYPES = [
+    'auth.otp.signup_verification',
+    'auth.otp.password_reset',
+    'auth.password_reset_link',
+];
+/** What happened to one message on one channel. */
+exports.DELIVERY_STATUSES = [
+    'sent',
+    'skipped_disabled',
+    'skipped_unreachable',
+    'failed',
+    'failed_missing_variables',
+];
+/** Only one version of a template per message type and channel is active. */
+exports.TEMPLATE_STATUSES = ['draft', 'active', 'archived'];

package/dist/esm/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/esm/app-settings/app-settings.dto.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import { utcTimestampSchema } from '../common/date-time.schema.js';
+import { MESSAGE_CATALOGUE } from '../communication/message-catalogue.js';
+import { MESSAGE_TYPES } 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 const APP_SETTING_KEYS = [
+    'communication.channels',
+    'communication.messages',
+];
+/** A switch per channel. */
+export const channelSwitchesSchema = z.strictObject({
+    EMAIL: z.boolean(),
+    SMS: z.boolean(),
+});
+/**
+ * Master switches: a channel switched off here sends nothing, whatever the
+ * per-message settings say.
+ */
+export const communicationChannelsSettingSchema = 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.
+ */
+export const communicationMessagesSettingSchema = z
+    .partialRecord(z.enum(MESSAGE_TYPES), channelSwitchesSchema)
+    .superRefine((value, ctx) => {
+    for (const [type, switches] of Object.entries(value)) {
+        const allowed = 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[type].label} cannot be sent by ${channel}`,
+                });
+            }
+        }
+    }
+});
+export const APP_SETTING_VALUE_SCHEMAS = {
+    'communication.channels': communicationChannelsSettingSchema,
+    'communication.messages': communicationMessagesSettingSchema,
+};
+/** Every message type, with its catalogue defaults: the effective value with nothing saved. */
+export function defaultMessageSettings() {
+    return Object.fromEntries(MESSAGE_TYPES.map((type) => [
+        type,
+        { ...MESSAGE_CATALOGUE[type].defaultChannels },
+    ]));
+}
+export const APP_SETTING_DEFAULTS = {
+    'communication.channels': { EMAIL: true, SMS: true },
+    'communication.messages': defaultMessageSettings(),
+};
+export const appSettingKeyParamSchema = z.enum(APP_SETTING_KEYS);
+export const appSettingResponseSchema = z.object({
+    key: z.enum(APP_SETTING_KEYS),
+    label: z.string(),
+    description: z.string(),
+    value: z.unknown(),
+    defaultValue: z.unknown(),
+    /** 0 until the setting is first saved. Send it back to update. */
+    version: z.number().int(),
+    updatedBy: z.uuid().nullable(),
+    updatedAt: utcTimestampSchema.nullable(),
+});
+export const appSettingListResponseSchema = z.array(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.
+ */
+export const updateAppSettingSchema = z.strictObject({
+    value: z.unknown(),
+    version: z.number().int().min(0),
+});
+export const appSettingHistoryEntrySchema = z.object({
+    id: z.uuid(),
+    key: z.enum(APP_SETTING_KEYS),
+    previousValue: z.unknown(),
+    newValue: z.unknown(),
+    version: z.number().int(),
+    actorUserId: z.uuid(),
+    createdAt: utcTimestampSchema,
+});
+export const appSettingHistoryResponseSchema = z.array(appSettingHistoryEntrySchema);

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

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

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

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

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

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

package/dist/esm/communication/index.js

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

package/dist/esm/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/esm/communication/message-catalogue.js

@@ -0,0 +1,50 @@
+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' },
+};
+export const 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. */
+export const MAX_SMS_LENGTH = 612;
+/** One GSM-7 segment. Longer messages are split and cost more. */
+export const SMS_SEGMENT_LENGTH = 160;