@acms-subir/core 0.3.55 → 0.3.56

package/src/lib/calendar/request-words.ts

@@ -0,0 +1,263 @@
+import type { RequestRefusal } from './request-service';
+
+// Words of event requests (lib/calendar/request-service.ts): the built-in
+// form at acms({ requests.path }), the emails to the person who asked (in
+// the language they asked in) and the staff alert (in the site's main
+// language). Plain strings with {time}, {email}, {phone}, {count}, {title}
+// and {when} slots (live/words.ts `fill`). Spanish uses usted, like the
+// other emails. The app's screen takes its EN/ES words from @acms-subir/native
+// (useStrings), whose tests check them against these. Other languages fall
+// back to English.
+
+export interface RequestStrings {
+  // the form
+  heading: string;
+  /** when the site set no notice of its own */
+  notice: string;
+  somethingNew: string;
+  change: string;
+  what: string;
+  type: string;
+  date: string;
+  starts: string;
+  ends: string;
+  repeats: string;
+  once: string;
+  weekly: string;
+  other: string;
+  otherHint: string;
+  room: string;
+  notSure: string;
+  /** the live room check: "{room} looks free then." / "{room} isn’t free then." */
+  free: string;
+  taken: string;
+  people: string;
+  message: string;
+  optional: string;
+  event: string;
+  pickEvent: string;
+  onDate: string;
+  onDateHint: string;
+  whatChange: string;
+  contact: string;
+  name: string;
+  email: string;
+  phone: string;
+  contactWhy: string;
+  privacy: string;
+  send: string;
+  closed: string;
+  /** after `closed`, with the site's phone */
+  call: string;
+  // sent
+  sent: string;
+  /** with the site's reply time ("3 days") */
+  answerWithin: string;
+  answerBy: string;
+  yours: string;
+  notYet: string;
+  sooner: string;
+  another: string;
+  /** "about {count} people" */
+  aboutPeople: string;
+  /** "Change to {title}" */
+  changeTo: string;
+  everyDate: string;
+  errors: Record<RequestRefusal | 'failed', string>;
+  // the emails to the person
+  mail: {
+    receivedSubject: string;
+    received: string;
+    /** after `received` when the site gave a reply time */
+    within: string;
+    replySubject: string;
+    reply: string;
+    approvedSubject: string;
+    approved: string;
+    approvedChange: string;
+    declinedSubject: string;
+    declined: string;
+    declinedChange: string;
+    fromTeam: string;
+    notYou: string;
+  };
+}
+
+const STRINGS: Record<string, RequestStrings> = {
+  en: {
+    heading: 'Request an event', notice: 'We review every request. It isn’t on the calendar until we confirm it.',
+    somethingNew: 'Something new', change: 'Change to an event', what: 'What are you planning?', type: 'Kind', date: 'Date', starts: 'Starts', ends: 'Ends',
+    repeats: 'Repeats', once: 'Just once', weekly: 'Every week', other: 'Something else', otherHint: 'Tell us how it repeats',
+    room: 'Room', notSure: 'Not sure', free: '{room} looks free then.', taken: '{room} isn’t free then.', people: 'How many people?', message: 'Anything else we should know?', optional: 'Optional',
+    event: 'Which event?', pickEvent: 'Choose an event', onDate: 'Which date?', onDateHint: 'Leave it empty if it’s about every date.', whatChange: 'What should change?',
+    contact: 'How we reach you', name: 'Your name', email: 'Email', phone: 'Phone', contactWhy: 'We use this only to answer your request.', privacy: 'Privacy',
+    send: 'Send request', closed: 'We aren’t taking requests here right now.', call: 'Call us at {phone}.',
+    sent: 'Request sent', answerWithin: 'We usually answer within {time}, by email to {email}.', answerBy: 'We’ll answer by email to {email}.',
+    yours: 'Your request', notYet: 'It isn’t on the calendar until we confirm it.', sooner: 'Need it sooner? Call {phone}.', another: 'Send another request',
+    aboutPeople: 'about {count} people', changeTo: 'Change to {title}', everyDate: 'every date',
+    errors: {
+      closed: 'We aren’t taking requests here right now.', trap: 'Couldn’t send this request.', busy: 'Too many requests. Try again in a minute.',
+      full: 'We’ve had a lot of requests today. Please try again tomorrow.', changed: 'This request was already sent. Reload the page to send a new one.',
+      title: 'Say what you’re planning.', type: 'Choose a kind from the list.', start: 'Pick a date and a start time.', end: 'Pick an end time within a day of the start.',
+      past: 'Pick a time that hasn’t passed.', far: 'Pick a date within the next two years.', repeat: 'Tell us how it repeats.', room: 'Choose a room from the list.',
+      people: 'Check the number of people.', event: 'Choose an event from the list.', date: 'That event doesn’t happen on that date.', what: 'Tell us what should change.',
+      name: 'Add your name.', email: 'Add a valid email address.', phone: 'Check the phone number, or leave it empty.', failed: 'Couldn’t send your request. Please try again.',
+    },
+    mail: {
+      receivedSubject: 'We got your request', received: 'We got your event request. It isn’t on the calendar until we confirm it.', within: 'We usually answer within {time}.',
+      replySubject: 'About your event request', reply: 'We wrote about your request:',
+      approvedSubject: 'Your request was approved', approved: 'We approved your event request. We’ll be in touch if we need anything else.', approvedChange: 'We approved your request, and we’ll make the change.',
+      declinedSubject: 'About your event request', declined: 'We’re sorry, we can’t take your event request.', declinedChange: 'We’re sorry, we can’t make the change you asked for.',
+      fromTeam: 'From the team:', notYou: 'If you didn’t send this request, you can ignore this email.',
+    },
+  },
+  es: {
+    heading: 'Solicitar un evento', notice: 'Revisamos cada solicitud. No estará en el calendario hasta que la confirmemos.',
+    somethingNew: 'Algo nuevo', change: 'Un cambio a un evento', what: '¿Qué está planeando?', type: 'Tipo', date: 'Fecha', starts: 'Comienza', ends: 'Termina',
+    repeats: 'Se repite', once: 'Solo una vez', weekly: 'Cada semana', other: 'Otra cosa', otherHint: 'Díganos cómo se repite',
+    room: 'Salón', notSure: 'No estoy seguro', free: '{room}: libre a esa hora.', taken: '{room}: no está libre a esa hora.', people: '¿Cuántas personas?', message: '¿Algo más que debamos saber?', optional: 'Opcional',
+    event: '¿Qué evento?', pickEvent: 'Elija un evento', onDate: '¿Qué fecha?', onDateHint: 'Déjelo vacío si es sobre todas las fechas.', whatChange: '¿Qué debe cambiar?',
+    contact: 'Cómo le contactamos', name: 'Su nombre', email: 'Correo electrónico', phone: 'Teléfono', contactWhy: 'Solo lo usamos para responder a su solicitud.', privacy: 'Privacidad',
+    send: 'Enviar solicitud', closed: 'Por ahora no recibimos solicitudes aquí.', call: 'Llámenos al {phone}.',
+    sent: 'Solicitud enviada', answerWithin: 'Normalmente respondemos en {time}, por correo a {email}.', answerBy: 'Le responderemos por correo a {email}.',
+    yours: 'Su solicitud', notYet: 'No estará en el calendario hasta que la confirmemos.', sooner: '¿La necesita antes? Llame al {phone}.', another: 'Enviar otra solicitud',
+    aboutPeople: 'unas {count} personas', changeTo: 'Cambio a {title}', everyDate: 'todas las fechas',
+    errors: {
+      closed: 'Por ahora no recibimos solicitudes aquí.', trap: 'No se pudo enviar esta solicitud.', busy: 'Demasiadas solicitudes. Inténtelo de nuevo en un minuto.',
+      full: 'Hoy hemos recibido muchas solicitudes. Inténtelo de nuevo mañana.', changed: 'Esta solicitud ya se envió. Vuelva a cargar la página para enviar otra.',
+      title: 'Diga qué está planeando.', type: 'Elija un tipo de la lista.', start: 'Elija una fecha y una hora de inicio.', end: 'Elija una hora de fin dentro de un día desde el inicio.',
+      past: 'Elija una hora que no haya pasado.', far: 'Elija una fecha dentro de los próximos dos años.', repeat: 'Díganos cómo se repite.', room: 'Elija un salón de la lista.',
+      people: 'Revise el número de personas.', event: 'Elija un evento de la lista.', date: 'Ese evento no ocurre en esa fecha.', what: 'Díganos qué debe cambiar.',
+      name: 'Escriba su nombre.', email: 'Escriba un correo electrónico válido.', phone: 'Revise el número de teléfono o déjelo vacío.', failed: 'No se pudo enviar su solicitud. Inténtelo de nuevo.',
+    },
+    mail: {
+      receivedSubject: 'Recibimos su solicitud', received: 'Recibimos su solicitud de evento. No estará en el calendario hasta que la confirmemos.', within: 'Normalmente respondemos en {time}.',
+      replySubject: 'Sobre su solicitud de evento', reply: 'Le escribimos sobre su solicitud:',
+      approvedSubject: 'Aprobamos su solicitud', approved: 'Aprobamos su solicitud de evento. Le escribiremos si necesitamos algo más.', approvedChange: 'Aprobamos su solicitud y haremos el cambio.',
+      declinedSubject: 'Sobre su solicitud de evento', declined: 'Lo sentimos, no podemos aceptar su solicitud de evento.', declinedChange: 'Lo sentimos, no podemos hacer el cambio que pidió.',
+      fromTeam: 'Del equipo:', notYou: 'Si usted no envió esta solicitud, puede ignorar este correo.',
+    },
+  },
+  fr: {
+    heading: 'Demander un événement', notice: 'Nous examinons chaque demande. Elle n’est pas au calendrier tant que nous ne l’avons pas confirmée.',
+    somethingNew: 'Quelque chose de nouveau', change: 'Un changement à un événement', what: 'Que prévoyez-vous ?', type: 'Type', date: 'Date', starts: 'Début', ends: 'Fin',
+    repeats: 'Se répète', once: 'Une seule fois', weekly: 'Chaque semaine', other: 'Autre chose', otherHint: 'Dites-nous comment cela se répète',
+    room: 'Salle', notSure: 'Je ne sais pas', free: '{room} : libre à cette heure-là.', taken: '{room} : pas libre à cette heure-là.', people: 'Combien de personnes ?', message: 'Autre chose à savoir ?', optional: 'Facultatif',
+    event: 'Quel événement ?', pickEvent: 'Choisissez un événement', onDate: 'Quelle date ?', onDateHint: 'Laissez vide si cela concerne toutes les dates.', whatChange: 'Que faut-il changer ?',
+    contact: 'Comment vous joindre', name: 'Votre nom', email: 'E-mail', phone: 'Téléphone', contactWhy: 'Nous l’utilisons uniquement pour répondre à votre demande.', privacy: 'Confidentialité',
+    send: 'Envoyer la demande', closed: 'Nous ne prenons pas de demandes ici pour le moment.', call: 'Appelez-nous au {phone}.',
+    sent: 'Demande envoyée', answerWithin: 'Nous répondons généralement sous {time}, par e-mail à {email}.', answerBy: 'Nous vous répondrons par e-mail à {email}.',
+    yours: 'Votre demande', notYet: 'Elle n’est pas au calendrier tant que nous ne l’avons pas confirmée.', sooner: 'Besoin d’une réponse plus tôt ? Appelez le {phone}.', another: 'Envoyer une autre demande',
+    aboutPeople: 'environ {count} personnes', changeTo: 'Changement : {title}', everyDate: 'toutes les dates',
+    errors: {
+      closed: 'Nous ne prenons pas de demandes ici pour le moment.', trap: 'Impossible d’envoyer cette demande.', busy: 'Trop de demandes. Réessayez dans une minute.',
+      full: 'Nous avons reçu beaucoup de demandes aujourd’hui. Réessayez demain.', changed: 'Cette demande a déjà été envoyée. Rechargez la page pour en envoyer une autre.',
+      title: 'Dites-nous ce que vous prévoyez.', type: 'Choisissez un type dans la liste.', start: 'Choisissez une date et une heure de début.', end: 'Choisissez une heure de fin dans les 24 heures après le début.',
+      past: 'Choisissez une heure qui n’est pas passée.', far: 'Choisissez une date dans les deux prochaines années.', repeat: 'Dites-nous comment cela se répète.', room: 'Choisissez une salle dans la liste.',
+      people: 'Vérifiez le nombre de personnes.', event: 'Choisissez un événement dans la liste.', date: 'Cet événement n’a pas lieu à cette date.', what: 'Dites-nous ce qu’il faut changer.',
+      name: 'Indiquez votre nom.', email: 'Indiquez une adresse e-mail valide.', phone: 'Vérifiez le numéro de téléphone ou laissez-le vide.', failed: 'Impossible d’envoyer votre demande. Réessayez.',
+    },
+    mail: {
+      receivedSubject: 'Nous avons reçu votre demande', received: 'Nous avons reçu votre demande d’événement. Elle n’est pas au calendrier tant que nous ne l’avons pas confirmée.', within: 'Nous répondons généralement sous {time}.',
+      replySubject: 'À propos de votre demande d’événement', reply: 'Nous vous écrivons au sujet de votre demande :',
+      approvedSubject: 'Votre demande est acceptée', approved: 'Nous avons accepté votre demande d’événement. Nous vous écrirons si nous avons besoin d’autre chose.', approvedChange: 'Nous avons accepté votre demande et ferons le changement.',
+      declinedSubject: 'À propos de votre demande d’événement', declined: 'Nous sommes désolés, nous ne pouvons pas accepter votre demande d’événement.', declinedChange: 'Nous sommes désolés, nous ne pouvons pas faire le changement demandé.',
+      fromTeam: 'De l’équipe :', notYou: 'Si vous n’avez pas envoyé cette demande, ignorez cet e-mail.',
+    },
+  },
+  de: {
+    heading: 'Veranstaltung anfragen', notice: 'Wir prüfen jede Anfrage. Sie steht erst im Kalender, wenn wir sie bestätigen.',
+    somethingNew: 'Etwas Neues', change: 'Änderung einer Veranstaltung', what: 'Was planen Sie?', type: 'Art', date: 'Datum', starts: 'Beginn', ends: 'Ende',
+    repeats: 'Wiederholung', once: 'Nur einmal', weekly: 'Jede Woche', other: 'Etwas anderes', otherHint: 'Sagen Sie uns, wie es sich wiederholt',
+    room: 'Raum', notSure: 'Weiß nicht', free: '{room}: zu dieser Zeit frei.', taken: '{room}: zu dieser Zeit nicht frei.', people: 'Wie viele Personen?', message: 'Sollten wir noch etwas wissen?', optional: 'Optional',
+    event: 'Welche Veranstaltung?', pickEvent: 'Veranstaltung wählen', onDate: 'Welches Datum?', onDateHint: 'Leer lassen, wenn es um alle Termine geht.', whatChange: 'Was soll sich ändern?',
+    contact: 'So erreichen wir Sie', name: 'Ihr Name', email: 'E-Mail', phone: 'Telefon', contactWhy: 'Wir verwenden dies nur, um Ihre Anfrage zu beantworten.', privacy: 'Datenschutz',
+    send: 'Anfrage senden', closed: 'Wir nehmen hier gerade keine Anfragen an.', call: 'Rufen Sie uns an: {phone}.',
+    sent: 'Anfrage gesendet', answerWithin: 'Wir antworten normalerweise innerhalb von {time}, per E-Mail an {email}.', answerBy: 'Wir antworten per E-Mail an {email}.',
+    yours: 'Ihre Anfrage', notYet: 'Sie steht erst im Kalender, wenn wir sie bestätigen.', sooner: 'Eilt es? Rufen Sie {phone} an.', another: 'Weitere Anfrage senden',
+    aboutPeople: 'etwa {count} Personen', changeTo: 'Änderung: {title}', everyDate: 'alle Termine',
+    errors: {
+      closed: 'Wir nehmen hier gerade keine Anfragen an.', trap: 'Diese Anfrage konnte nicht gesendet werden.', busy: 'Zu viele Anfragen. Versuchen Sie es in einer Minute erneut.',
+      full: 'Heute sind viele Anfragen eingegangen. Bitte versuchen Sie es morgen erneut.', changed: 'Diese Anfrage wurde schon gesendet. Laden Sie die Seite neu, um eine neue zu senden.',
+      title: 'Sagen Sie uns, was Sie planen.', type: 'Wählen Sie eine Art aus der Liste.', start: 'Wählen Sie ein Datum und eine Beginnzeit.', end: 'Wählen Sie ein Ende innerhalb eines Tages nach dem Beginn.',
+      past: 'Wählen Sie eine Zeit, die noch nicht vorbei ist.', far: 'Wählen Sie ein Datum in den nächsten zwei Jahren.', repeat: 'Sagen Sie uns, wie es sich wiederholt.', room: 'Wählen Sie einen Raum aus der Liste.',
+      people: 'Prüfen Sie die Zahl der Personen.', event: 'Wählen Sie eine Veranstaltung aus der Liste.', date: 'An diesem Datum findet die Veranstaltung nicht statt.', what: 'Sagen Sie uns, was sich ändern soll.',
+      name: 'Geben Sie Ihren Namen an.', email: 'Geben Sie eine gültige E-Mail-Adresse an.', phone: 'Prüfen Sie die Telefonnummer oder lassen Sie sie leer.', failed: 'Ihre Anfrage konnte nicht gesendet werden. Bitte versuchen Sie es erneut.',
+    },
+    mail: {
+      receivedSubject: 'Wir haben Ihre Anfrage erhalten', received: 'Wir haben Ihre Veranstaltungsanfrage erhalten. Sie steht erst im Kalender, wenn wir sie bestätigen.', within: 'Wir antworten normalerweise innerhalb von {time}.',
+      replySubject: 'Zu Ihrer Veranstaltungsanfrage', reply: 'Wir schreiben Ihnen zu Ihrer Anfrage:',
+      approvedSubject: 'Ihre Anfrage wurde angenommen', approved: 'Wir haben Ihre Veranstaltungsanfrage angenommen. Wir melden uns, falls wir noch etwas brauchen.', approvedChange: 'Wir haben Ihre Anfrage angenommen und nehmen die Änderung vor.',
+      declinedSubject: 'Zu Ihrer Veranstaltungsanfrage', declined: 'Es tut uns leid, wir können Ihre Veranstaltungsanfrage nicht annehmen.', declinedChange: 'Es tut uns leid, wir können die gewünschte Änderung nicht vornehmen.',
+      fromTeam: 'Vom Team:', notYou: 'Wenn Sie diese Anfrage nicht gesendet haben, ignorieren Sie diese E-Mail.',
+    },
+  },
+  pt: {
+    heading: 'Solicitar um evento', notice: 'Analisamos cada solicitação. Ela não entra no calendário até que a confirmemos.',
+    somethingNew: 'Algo novo', change: 'Uma mudança em um evento', what: 'O que você está planejando?', type: 'Tipo', date: 'Data', starts: 'Começa', ends: 'Termina',
+    repeats: 'Repete', once: 'Só uma vez', weekly: 'Toda semana', other: 'Outra coisa', otherHint: 'Conte como se repete',
+    room: 'Sala', notSure: 'Não sei', free: '{room}: livre nesse horário.', taken: '{room}: não está livre nesse horário.', people: 'Quantas pessoas?', message: 'Algo mais que devemos saber?', optional: 'Opcional',
+    event: 'Qual evento?', pickEvent: 'Escolha um evento', onDate: 'Qual data?', onDateHint: 'Deixe vazio se for sobre todas as datas.', whatChange: 'O que deve mudar?',
+    contact: 'Como falamos com você', name: 'Seu nome', email: 'E-mail', phone: 'Telefone', contactWhy: 'Usamos isso só para responder à sua solicitação.', privacy: 'Privacidade',
+    send: 'Enviar solicitação', closed: 'No momento não estamos recebendo solicitações aqui.', call: 'Ligue para {phone}.',
+    sent: 'Solicitação enviada', answerWithin: 'Normalmente respondemos em {time}, por e-mail para {email}.', answerBy: 'Responderemos por e-mail para {email}.',
+    yours: 'Sua solicitação', notYet: 'Ela não entra no calendário até que a confirmemos.', sooner: 'Precisa antes? Ligue para {phone}.', another: 'Enviar outra solicitação',
+    aboutPeople: 'cerca de {count} pessoas', changeTo: 'Mudança em {title}', everyDate: 'todas as datas',
+    errors: {
+      closed: 'No momento não estamos recebendo solicitações aqui.', trap: 'Não foi possível enviar esta solicitação.', busy: 'Muitas solicitações. Tente de novo em um minuto.',
+      full: 'Recebemos muitas solicitações hoje. Tente de novo amanhã.', changed: 'Esta solicitação já foi enviada. Recarregue a página para enviar outra.',
+      title: 'Conte o que você está planejando.', type: 'Escolha um tipo da lista.', start: 'Escolha uma data e um horário de início.', end: 'Escolha um horário de término até um dia depois do início.',
+      past: 'Escolha um horário que ainda não passou.', far: 'Escolha uma data nos próximos dois anos.', repeat: 'Conte como se repete.', room: 'Escolha uma sala da lista.',
+      people: 'Confira o número de pessoas.', event: 'Escolha um evento da lista.', date: 'Esse evento não acontece nessa data.', what: 'Conte o que deve mudar.',
+      name: 'Informe seu nome.', email: 'Informe um e-mail válido.', phone: 'Confira o telefone ou deixe-o vazio.', failed: 'Não foi possível enviar sua solicitação. Tente de novo.',
+    },
+    mail: {
+      receivedSubject: 'Recebemos sua solicitação', received: 'Recebemos sua solicitação de evento. Ela não entra no calendário até que a confirmemos.', within: 'Normalmente respondemos em {time}.',
+      replySubject: 'Sobre sua solicitação de evento', reply: 'Escrevemos sobre sua solicitação:',
+      approvedSubject: 'Sua solicitação foi aprovada', approved: 'Aprovamos sua solicitação de evento. Entraremos em contato se precisarmos de mais alguma coisa.', approvedChange: 'Aprovamos sua solicitação e faremos a mudança.',
+      declinedSubject: 'Sobre sua solicitação de evento', declined: 'Sentimos muito, não podemos aceitar sua solicitação de evento.', declinedChange: 'Sentimos muito, não podemos fazer a mudança que você pediu.',
+      fromTeam: 'Da equipe:', notYou: 'Se você não enviou esta solicitação, ignore este e-mail.',
+    },
+  },
+};
+
+export const requestStrings = (locale: string | null | undefined): RequestStrings =>
+  STRINGS[(locale || 'en').toLowerCase().split('-')[0]] ?? STRINGS.en;
+
+// The staff alert and its push, in the site's main language.
+export interface RequestStaffWords {
+  subjectNew: string; subjectChange: string; subjectMove: string;
+  intro: Record<'app' | 'web' | 'member', string>;
+  when: string; repeats: string; rooms: string; roomsUnsure: string; people: string; type: string; from: string; language: string;
+  message: string; whatChange: string; date: string; everyDate: string; open: string; why: string;
+  pushTitle: string; pushBody: string;
+}
+const STAFF: Record<string, RequestStaffWords> = {
+  en: { subjectNew: 'New event request: {title}', subjectChange: 'Change requested: {title}', subjectMove: 'Date move to review: {title}',
+    intro: { app: 'Sent from the app.', web: 'Sent from the website.', member: 'Sent by a host from My events.' },
+    when: 'When', repeats: 'Repeats', rooms: 'Rooms', roomsUnsure: 'Not sure', people: 'People', type: 'Kind', from: 'From', language: 'Language',
+    message: 'Their message', whatChange: 'What should change', date: 'Date', everyDate: 'Every date', open: 'Review requests',
+    why: 'You get these because you’re on the list for new event requests.', pushTitle: 'New event request', pushBody: 'For {when}. Review it in the admin.' },
+  es: { subjectNew: 'Nueva solicitud de evento: {title}', subjectChange: 'Cambio solicitado: {title}', subjectMove: 'Cambio de fecha por revisar: {title}',
+    intro: { app: 'Enviada desde la app.', web: 'Enviada desde el sitio web.', member: 'Enviada por un anfitrión desde Mis eventos.' },
+    when: 'Cuándo', repeats: 'Se repite', rooms: 'Salones', roomsUnsure: 'No está seguro', people: 'Personas', type: 'Tipo', from: 'De', language: 'Idioma',
+    message: 'Su mensaje', whatChange: 'Qué debe cambiar', date: 'Fecha', everyDate: 'Todas las fechas', open: 'Revisar solicitudes',
+    why: 'Recibe estos correos porque está en la lista de nuevas solicitudes de eventos.', pushTitle: 'Nueva solicitud de evento', pushBody: 'Para el {when}. Revísela en el panel.' },
+  fr: { subjectNew: 'Nouvelle demande d’événement : {title}', subjectChange: 'Changement demandé : {title}', subjectMove: 'Changement de date à examiner : {title}',
+    intro: { app: 'Envoyée depuis l’app.', web: 'Envoyée depuis le site.', member: 'Envoyée par un responsable depuis Mes événements.' },
+    when: 'Quand', repeats: 'Se répète', rooms: 'Salles', roomsUnsure: 'Ne sait pas', people: 'Personnes', type: 'Type', from: 'De', language: 'Langue',
+    message: 'Son message', whatChange: 'Ce qu’il faut changer', date: 'Date', everyDate: 'Toutes les dates', open: 'Voir les demandes',
+    why: 'Vous recevez ces e-mails parce que vous êtes sur la liste des nouvelles demandes d’événements.', pushTitle: 'Nouvelle demande d’événement', pushBody: 'Pour le {when}. À examiner dans l’administration.' },
+  de: { subjectNew: 'Neue Veranstaltungsanfrage: {title}', subjectChange: 'Änderung angefragt: {title}', subjectMove: 'Terminverschiebung zu prüfen: {title}',
+    intro: { app: 'Über die App gesendet.', web: 'Über die Website gesendet.', member: 'Von einer Leitung über Meine Veranstaltungen gesendet.' },
+    when: 'Wann', repeats: 'Wiederholung', rooms: 'Räume', roomsUnsure: 'Weiß nicht', people: 'Personen', type: 'Art', from: 'Von', language: 'Sprache',
+    message: 'Nachricht', whatChange: 'Was sich ändern soll', date: 'Datum', everyDate: 'Alle Termine', open: 'Anfragen ansehen',
+    why: 'Sie erhalten diese E-Mails, weil Sie auf der Liste für neue Veranstaltungsanfragen stehen.', pushTitle: 'Neue Veranstaltungsanfrage', pushBody: 'Für {when}. Bitte in der Verwaltung prüfen.' },
+  pt: { subjectNew: 'Nova solicitação de evento: {title}', subjectChange: 'Mudança solicitada: {title}', subjectMove: 'Mudança de data para revisar: {title}',
+    intro: { app: 'Enviada pelo app.', web: 'Enviada pelo site.', member: 'Enviada por um anfitrião em Meus eventos.' },
+    when: 'Quando', repeats: 'Repete', rooms: 'Salas', roomsUnsure: 'Não sabe', people: 'Pessoas', type: 'Tipo', from: 'De', language: 'Idioma',
+    message: 'Mensagem', whatChange: 'O que deve mudar', date: 'Data', everyDate: 'Todas as datas', open: 'Ver solicitações',
+    why: 'Você recebe estes e-mails porque está na lista de novas solicitações de eventos.', pushTitle: 'Nova solicitação de evento', pushBody: 'Para {when}. Revise no painel.' },
+};
+export const requestStaffWords = (locale: string | null | undefined): RequestStaffWords =>
+  STAFF[(locale || 'en').toLowerCase().split('-')[0]] ?? STAFF.en;

package/src/lib/email/service.ts

@@ -39,6 +39,11 @@ async function render(repo: ContentRepository, job: EmailJob, locals?: unknown,
     return { ...mail, to: job.recipient };
   }
   if (job.kind === 'form-alert') return formAlertMail(repo, job.recipient, JSON.parse(job.payload) as AlertPayload, origin);
+  // event requests without an account (lib/calendar/request-service.ts)
+  if (job.kind === 'calendar-request') {
+    const { requestMail } = await import('../calendar/request-mail');
+    return requestMail(repo, job.recipient, JSON.parse(job.payload), origin);
+  }
   if (job.kind === 'auth') {
     const payload = JSON.parse(job.payload);
     const token = await repo.email.token(payload.tokenId);
@@ -109,7 +114,7 @@ export async function dispatchEmail(repo: ContentRepository, locals?: unknown, l
       }
       await repo.email.pin(j,resolved.provider,resolved.fingerprint,config?.version || 0);
       if (await repo.email.suppressed(j.recipient)) { await repo.email.finish(j,{state:'suppressed',error:'Recipient is suppressed after a bounce or complaint.'}); continue; }
-      if (j.kind === 'booking' || j.kind === 'event-request') {
+      if (j.kind === 'booking' || j.kind === 'event-request' || j.kind === 'calendar-request') {
         const payload = JSON.parse(j.payload);
         if ((payload.kind === 'reminder' && !current.config.reminders) || (String(payload.kind).startsWith('staff-') && !current.config.staffNotifications)) {
           await repo.email.finish(j,{state:'cancelled',error:'Optional notification disabled.'}); continue;

package/src/lib/legal/app-privacy.ts

@@ -11,7 +11,7 @@ export interface AppPrivacyAnswers { rows: StoreRow[]; tracking: string; notes:
 export function appPrivacyAnswers(f: LegalFacts, privacyUrl: string): AppPrivacyAnswers {
   const rows: StoreRow[] = [];
   // apps can RSVP (or join a full date's waitlist) wherever the calendar is on; room bookings need bookings too
-  const contact = [...(f.bookings ? ['bookings'] : []), ...(f.calendar ? ['RSVPs (including waitlist requests)'] : []), ...(f.appForms ? ['forms'] : [])];
+  const contact = [...(f.bookings ? ['bookings'] : []), ...(f.calendar ? ['RSVPs (including waitlist requests)'] : []), ...(f.appForms ? ['forms'] : []), ...(f.requests.enabled ? ['event requests'] : [])];
   const sends = contact.length > 1 ? `${contact.slice(0, -1).join(', ')} or ${contact.at(-1)}` : contact[0];
   if (contact.length) {
     rows.push({
@@ -20,7 +20,7 @@ export function appPrivacyAnswers(f: LegalFacts, privacyUrl: string): AppPrivacy
       google: 'Personal info → Name, Email address, Phone number. Collected, not shared. Purpose: App functionality. Optional (people choose to send it).',
     });
     rows.push({
-      data: 'Answers typed into a form or booking question', when: `When someone sends ${sends} from the app`,
+      data: f.requests.enabled ? 'Answers typed into a form or booking question, and the message of an event request' : 'Answers typed into a form or booking question', when: `When someone sends ${sends} from the app`,
       apple: 'User Content → Other User Content. Purpose: App Functionality. Linked to the user. Not used for tracking.',
       google: 'App activity → Other user-generated content. Collected, not shared. Purpose: App functionality. Optional.',
     });

package/src/lib/legal/facts.ts

@@ -4,6 +4,7 @@ import type { Settings } from '../schema';
 import { CALENDAR, bookingsEnabled } from '../calendar/config';
 import { PUSH } from '../push/config';
 import { ANNOUNCEMENTS } from '../announcements/config';
+import { REQUESTS } from '../calendar/request-config';
 import { AUTH } from '../auth/config';
 import { EDITOR } from '../editor/config';
 import { SITE_ROLES } from '../roles';
@@ -44,6 +45,8 @@ export interface LegalFacts {
   googleCalendar: boolean;
   /** acms({ announcements }): urgent ones reach every device; read and closed state stays in the app */
   announcements: boolean;
+  /** acms({ requests }): event requests without an account, kept keepDays after the answer */
+  requests: { enabled: boolean; keepDays: number };
   analytics: { umami: boolean; replay: boolean; meta: boolean; tiktok: boolean };
   ai: boolean;
   offsiteBackups: boolean;
@@ -86,6 +89,7 @@ export async function legalFacts(repo: ContentRepository, settings: Settings, lo
     live: settings.live.mode !== 'off',
     googleCalendar: CALENDAR.enabled && await repo.gcal.account().then((a) => !!a && a.status !== 'setup').catch(() => false),
     announcements: ANNOUNCEMENTS.enabled,
+    requests: { enabled: REQUESTS.enabled, keepDays: settings.calendar.requests.keepDays },
     analytics: {
       umami: a.umami.enabled && !!a.umami.websiteId,
       replay: a.umami.enabled && !!a.umami.websiteId && a.umami.replay.enabled,

package/src/lib/legal/text-en.ts

@@ -49,6 +49,9 @@ export function privacyEn(f: LegalFacts, country: string): PolicySection[] {
   s.push({ id: 'forms', title: 'Forms', text: [
     `When you send a form, we store your answers as you entered them (for example your name, email address or phone number, if the form asks for them) and when you sent it. Staff with access to form responses can read and export them. We don’t store your IP address with a response.${f.email ? ' Responses, or a notice that one arrived, may be emailed to the staff who handle that form.' : ''}`,
   ] });
+  if (f.requests.enabled) s.push({ id: 'requests', title: 'Event requests', text: [
+    `When you ask us for an event, or a change to one, on this site${app ? ' or in our app' : ''}, we store your name, email address, any phone number, the language you used, the details you give (what, when, which rooms, how many people) and your message. We use them only to answer your request: staff who manage the calendar read it, and we email you that it arrived and our answer. Your contact details never appear on a published event. We delete a request ${days(f.requests.keepDays)} after we answer it, or ${days(f.requests.keepDays)} after it arrives if we never do; site backups may keep a copy for a while longer.`,
+  ] });
   if (f.guestSignIn) s.push({ id: 'guest', title: 'Signing in to see your bookings', text: [
     'To see your bookings in our app, you can sign in with your email address. We email you a six-digit code that expires after 10 minutes. We keep your email address and that sign-in on your device until you sign out or don’t use it for 90 days.',
   ] });

package/src/lib/legal/text-es.ts

@@ -50,6 +50,9 @@ export function privacyEs(f: LegalFacts, country: string): PolicySection[] {
   s.push({ id: 'forms', title: 'Formularios', text: [
     `Cuando envía un formulario, guardamos sus respuestas tal como las escribió (por ejemplo su nombre, correo o teléfono, si el formulario los pide) y la fecha en que lo envió. El personal con acceso a las respuestas puede leerlas y exportarlas. No guardamos su dirección IP con la respuesta.${f.email ? ' Sus respuestas, o un aviso de que llegaron, pueden enviarse por correo al personal que atiende ese formulario.' : ''}`,
   ] });
+  if (f.requests.enabled) s.push({ id: 'requests', title: 'Solicitudes de eventos', text: [
+    `Cuando nos pide un evento, o un cambio a uno, en este sitio${app ? ' o en nuestra app' : ''}, guardamos su nombre, su correo electrónico, el teléfono si lo da, el idioma que usó, los detalles que nos da (qué, cuándo, qué salones, cuántas personas) y su mensaje. Los usamos solo para responder a su solicitud: el personal que administra el calendario la lee, y le escribimos por correo que llegó y nuestra respuesta. Sus datos de contacto nunca aparecen en un evento publicado. Borramos la solicitud ${days(f.requests.keepDays)} después de responderla, o ${days(f.requests.keepDays)} después de recibirla si no la respondemos; las copias de seguridad del sitio pueden conservar una copia un tiempo más.`,
+  ] });
   if (f.guestSignIn) s.push({ id: 'guest', title: 'Inicio de sesión para ver sus reservaciones', text: [
     'Para ver sus reservaciones en nuestra app, puede iniciar sesión con su correo electrónico. Le enviamos un código de seis dígitos que vence a los 10 minutos. Guardamos su correo y esa sesión en su dispositivo hasta que la cierre o pasen 90 días sin usarla.',
   ] });

package/src/lib/mobile/http.ts

@@ -33,7 +33,8 @@ export function failure(error: unknown) {
   const status = error instanceof ApiError || error instanceof BookingError ? error.status : error instanceof z.ZodError ? 400 : 500;
   const codes: Record<number, string> = { 400: 'invalid_request', 401: 'unauthorized', 403: 'forbidden', 404: 'not_found', 405: 'method_not_allowed', 409: 'conflict', 410: 'gone', 413: 'payload_too_large', 415: 'unsupported_media_type', 429: 'rate_limited', 502: 'upstream_error' };
   return Response.json({ version: 1, error: {
-    code: (error instanceof BookingError && error.code) || (codes[status] ?? 'internal_error'),
+    // a refusal's own code (BookingError, or an ApiError with one: requests, moves)
+    code: ((error instanceof BookingError || error instanceof ApiError) && typeof (error as { code?: unknown }).code === 'string' && (error as { code: string }).code) || (codes[status] ?? 'internal_error'),
     message: status === 500 ? 'Request failed. Please try again.' : error instanceof z.ZodError ? 'Invalid request parameters.' : (error as Error).message,
     ...(error instanceof z.ZodError ? { issues: error.issues.map(({ path, message }) => ({ path, message })) } : {}),
   } }, { status, headers: { ...headers, ...(status === 429 ? { 'Retry-After': String((error as ApiError).retryAfter ?? 60) } : {}),

package/src/lib/mobile/openapi.ts

@@ -9,6 +9,8 @@ import { pagesQuery } from './pages';
 import { searchQuery } from './search';
 import { manageAvailabilityQuery, rescheduleInput } from './manage';
 import { formResponseInput } from './forms';
+import { requestOptionsQuery } from './requests';
+import { RequestInput } from '../calendar/request-service';
 import { codeInput, tokenInput, myBookingsQuery } from './guest';
 import { deviceInput, deviceUpdate, staffLinkInput } from '../push/api';
 import { announcementsQuery } from '../announcements/api';
@@ -116,6 +118,12 @@ export async function getOpenApi(_repo: ContentRepository, url: URL) {
   paths['/api/v1/forms/{id}/responses'] = { post: { ...priv('Send a response to a published form', ref('FormReceipt'), { body: formResponseInput, write: true, status: 201,
     description: 'Same validation as the web form. Idempotency-Key (UUID v4) is the response id: retries never duplicate. 10 responses per address per form per minute, plus the owner’s daily ceiling per form (429). version from GET /forms/{id}: a changed form answers 409 (a translation alone doesn’t change it). A choice may be sent as shown in the requested language or in the main one; it is stored as the main-language choice. A time answer is HH:mm (24-hour). locale: the confirmation in that language (one the site doesn’t have gets the main language’s). Leave website empty (spam trap).' }),
     parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }, { name: 'locale', in: 'query', required: false, schema: { type: 'string', minLength: 1, maxLength: 35 } }, { name: 'Idempotency-Key', in: 'header', required: true, schema: { type: 'string', format: 'uuid' } }] }, ...cors };
+  const requestNote = 'Requires acms({ requests }) (site.features.requests); 404 when off. No account.';
+  paths['/api/v1/requests/options'] = { get: priv('What the event request form offers: open or closed, the types, requestable rooms and changeable events (with their dates), the site’s reply time and notice (in the requested language) and its phone', ref('RequestOptions'), { query: requestOptionsQuery,
+    description: `${requestNote} Never cached. When open is false, say so and show phone; keep the screen itself reachable. Check whether a room is free with GET /rooms/free.` }), ...cors };
+  paths['/api/v1/requests'] = { post: { ...priv('Ask for a new event or a change to one, without an account', ref('RequestReceipt'), { body: RequestInput, write: true, status: 201,
+    description: `${requestNote} kind new: type (from options; required when the site lists types), title, start (site-local YYYY-MM-DDTHH:mm, in the future), end (the same, or HH:mm: the start's day, or the next when it's before the start; within a day), repeat (once, weekly, or other with repeatText), rooms (slugs from options) or roomsUnsure, people, message. kind change: event (a public event's slug), date (YYYY-MM-DD, optional: one of its dates; none = every date), message (what should change, required). name and email are required, phone optional; locale is the language for replies. Idempotency-Key (UUID v4) is the request's id: a retry answers the same, other details with the same key answer 409 changed. Refusals carry a code (see Error). 10 requests a minute and 20 a day per client address, 5 a day per email address, and the site's daily cap (429). A retry is answered before any limit. Leave website empty (spam trap). The person gets an email that it arrived, without the words they typed.` }),
+    parameters: [{ name: 'Idempotency-Key', in: 'header', required: true, schema: { type: 'string', format: 'uuid' } }] }, ...cors };
   const guestNote = 'Guest sign-in needs the calendar, working email, EMAIL_ENCRYPTION_KEY and the owner switch guestSignIn (site.features.guestSignIn); 404 otherwise.';
   paths['/api/v1/guest/code'] = { post: priv('Email a 6-digit sign-in code (always answers the same, whether or not the address has bookings)', ref('GuestCodeSent'), { body: codeInput, write: true, status: 202,
     description: `${guestNote} Codes last 10 minutes; a new request voids the old code. 3 codes per address and 20 per client address per 15 minutes.` }), ...cors };

package/src/lib/mobile/requests.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { ApiError, readJson } from '../api';
+import { REQUESTS } from '../calendar/request-config';
+import { requestOptions, submitRequest } from '../calendar/request-service';
+import { queryParams } from './http';
+import type { PublicContext } from './route';
+
+// Event requests from apps (acms({ requests })): the options the form needs,
+// and sending one. No account; an Idempotency-Key per request (retries never
+// duplicate); 10 a minute per address and the site's daily cap
+// (lib/calendar/request-service.ts holds the rules). Never cached: "closed"
+// and the rooms must show at once.
+
+export const requestOptionsQuery = z.object({ locale: z.string().max(35).optional() }).strict();
+
+export async function getRequestOptions(c: PublicContext) {
+  if (!REQUESTS.enabled) throw new ApiError(404, 'Not found.');
+  const q = requestOptionsQuery.parse(queryParams(c.url));
+  return requestOptions(c.repo, q.locale);
+}
+
+export async function postRequest(c: PublicContext) {
+  const key = c.request.headers.get('idempotency-key') ?? '';
+  const body = await readJson(c.request, 20_000);
+  const { id } = await submitRequest(c.repo, body, { source: 'app', key, address: c.address, locals: c.locals });
+  return { id };
+}

package/src/lib/mobile/schemas.ts

@@ -9,7 +9,7 @@ const Palette = z.object({ bg: str, ink: str, muted: str, line: str, accent: str
 export const Site = z.object({
   name: str, description: str, logo: str, logoDark: str, icon: str, menu: z.array(z.object({ label: str, href: str })),
   languages: z.object({ default: locale, locales: z.array(z.object({ code: str, name: str })) }),
-  features: z.object({ blog: z.array(z.object({ key: str, name: str, url: str, redirectFrom: strings })), calendar: bool, bookings: bool, rsvp: bool, search: bool, bookingChanges: bool, guestSignIn: bool, forms: bool, links: bool, live: bool, announcements: bool }),
+  features: z.object({ blog: z.array(z.object({ key: str, name: str, url: str, redirectFrom: strings })), calendar: bool, bookings: bool, rsvp: bool, search: bool, bookingChanges: bool, guestSignIn: bool, forms: bool, links: bool, live: bool, announcements: bool, requests: bool }),
   legal: z.object({ privacy: str.nullable(), terms: str.nullable() }), apiVersion: z.literal(1),
 });
 export const Theme = z.object({
@@ -159,8 +159,19 @@ export const LiveStatus = z.object({
   snapshot: LiveSnapshot.nullable(), serverNow: ms,
   display: z.object({ style: z.enum(['poster', 'split', 'row']), bar: bool, header: bool, dock: bool }),
 });
+// GET /requests/options: types and rooms to offer, the site's words (in the asked language), the phone for when it's closed
+export const RequestOptions = z.object({
+  open: bool, types: z.array(z.object({ id: str, label: str })), rooms: z.array(z.object({ slug: str, name: str, color: str })),
+  replyTime: str, notice: str, phone: str, timezone: str,
+  // what a change can be about: public events by title, each with its dates (site-local days) in the next 120 days
+  events: z.array(z.object({ slug: str, title: str, dates: z.array(str) })),
+});
+export const RequestReceipt = z.object({ id: str });
 export const Error = z.object({ version: z.literal(1), error: z.object({
-  // duplicate (409): that email already has an RSVP for the date
-  code: z.enum(['invalid_request', 'unauthorized', 'forbidden', 'not_found', 'method_not_allowed', 'conflict', 'duplicate', 'gone', 'payload_too_large', 'unsupported_media_type', 'rate_limited', 'upstream_error', 'internal_error']),
+  // duplicate (409): that email already has an RSVP for the date. POST /requests refusals say
+  // which field (title, type, start, end, past, far, repeat, room, people, event, date, what,
+  // name, email, phone; 400), closed or changed (409), busy or full (429), trap (400)
+  code: z.enum(['invalid_request', 'unauthorized', 'forbidden', 'not_found', 'method_not_allowed', 'conflict', 'duplicate', 'gone', 'payload_too_large', 'unsupported_media_type', 'rate_limited', 'upstream_error', 'internal_error',
+    'closed', 'trap', 'busy', 'full', 'changed', 'title', 'type', 'start', 'end', 'past', 'far', 'repeat', 'room', 'people', 'event', 'date', 'what', 'name', 'email', 'phone']),
   message: str, issues: z.array(z.object({ path: z.array(z.union([str, z.number()])), message: str })).optional(),
 }) });

package/src/lib/mobile/site.ts

@@ -4,6 +4,7 @@ import { CONTENT, legacyBases } from '../content';
 import { I18N, localeName } from '../i18n';
 import { CALENDAR, bookingsEnabled } from '../calendar/config';
 import { ANNOUNCEMENTS } from '../announcements/config';
+import { REQUESTS } from '../calendar/request-config';
 import { SEARCH } from '../search-config';
 import { siteOrigin } from '../seo';
 import { resolveDesign } from '../theme';
@@ -51,6 +52,8 @@ export async function getSite(repo: ContentRepository, url: URL, _id = '', local
       live: settings.live.mode !== 'off',
       // acms({ announcements }): GET /api/v1/announcements
       announcements: ANNOUNCEMENTS.enabled,
+      // acms({ requests }): GET /api/v1/requests/options, POST /api/v1/requests (on even while requests are closed)
+      requests: REQUESTS.enabled,
     },
     // in the requested language (?locale=es → /es/privacy)
     legal: { privacy: legalUrl('privacy'), terms: legalUrl('terms') },

package/src/lib/push/types.ts

@@ -57,7 +57,7 @@ export interface PushDevice {
  * new form response, to the linked phones of staff on its alert list. Neither
  * counts in the weekly pace.
  */
-export type PushSource = 'manual' | 'post' | 'event' | 'soon' | 'live' | 'announcement' | 'change' | 'test' | 'form';
+export type PushSource = 'manual' | 'post' | 'event' | 'soon' | 'live' | 'announcement' | 'change' | 'test' | 'form' | 'request';
 export interface PushNotification {
   id: string; title: string; body: string; url: string;
   /** ['*'] = everyone */

package/src/lib/scheduler.ts

@@ -6,6 +6,7 @@ import { dispatchEmail } from './email/service';
 import { decideOverdue, sendDueReminders, sweepWaitlist } from './booking/service';
 import { runPushJobs } from './push/service';
 import { runAnnouncementJobs } from './announcements/service';
+import { pruneRequests } from './calendar/request-service';
 import { GUEST_IDLE_MS } from './mobile/guest-store';
 import { pushHeartbeat, pushUrlFor } from './monitoring';
 import { syncCachePurge } from './cache/purge';
@@ -35,6 +36,8 @@ export async function runScheduledTasks(repo: ContentRepository, locals?: unknow
     announcements: () => runAnnouncementJobs(repo, { locals, now: startedAt }),
     // queued first-publish notices, starting-soon reminders, receipts, retention
     push: () => runPushJobs(repo, { locals, now: startedAt }),
+    // event requests past Calendar → Requests' retention (after the answer, or after arriving if nobody answered)
+    requests: () => pruneRequests(repo, startedAt),
     // expired guest sign-in codes and app sessions unused for 90 days
     guests: () => repo.guests.purge(GUEST_IDLE_MS, startedAt).then(() => 0),
     // clear shared caches after scheduled publishes, and retry a purge that

package/src/lib/schema.ts

@@ -406,8 +406,10 @@ export type EventRequest = z.infer<typeof EventRequest>;
 //   on (C3/C4); `data` holds the move.
 // `userId` is the member who asked; `requester` is the person without an
 // account (never both). `note` is their own words to staff, `reply` staff's
-// last answer. Decided rows (and withdrawn ones, which set reviewedAt too)
-// are deleted some days after `reviewedAt` (CalendarSettings.requests).
+// last answer. `data.sent` on new and change requests is a hash of what was
+// sent (a retry must match it). Rows are deleted some days after
+// `reviewedAt` (withdrawing sets it too), or after `createdAt` while nobody
+// answered (CalendarSettings.requests).
 export const RequestKind = z.enum(['new', 'change', 'move', 'from-date']);
 export type RequestKind = z.infer<typeof RequestKind>;
 export const RequestState = z.enum(['pending', 'approved', 'declined', 'withdrawn']);
@@ -651,6 +653,44 @@ export type ApprovalRules = z.infer<typeof ApprovalRules>;
 export const EventImageUrl = z.string().trim().max(2000).refine((value) => !value || Boolean(safeEventImageUrl(value)), 'Choose an image or use an http(s) URL or site-relative image path.');
 
 // Site-wide calendar preferences (Calendar settings → Defaults / Bookings)
+// Event requests from people without an account (acms({ requests }),
+// lib/calendar/request-service.ts), set on Calendar → Requests. A type is
+// what people pick under "Kind" (Class, Meeting…): approving a request makes
+// a draft with its tag, in its calendar.
+export const RequestType = z.object({
+  id: z.string().regex(/^[a-z0-9][a-z0-9-]{0,39}$/),
+  label: z.string().min(1).max(60),
+  // the label in each other site language
+  translations: z.record(z.string().max(60)).default({}),
+  // what an approved draft gets: this tag ('' = none), this calendar ('' = the default calendar)
+  tag: z.string().max(60).default(''),
+  calendarId: z.string().default(''),
+});
+export type RequestType = z.infer<typeof RequestType>;
+export const RequestWords = z.object({ replyTime: z.string().max(60).default(''), notice: z.string().max(400).default('') });
+export const RequestSettings = z.object({
+  // closed: the form says so (with the phone number) and new requests are refused
+  open: z.boolean().default(true),
+  types: z.array(RequestType).max(12).default([]),
+  // "We usually answer within {replyTime}" ("3 days"); '' leaves the sentence out
+  replyTime: z.string().max(60).default(''),
+  // the form's opening line ('' = the built-in "It isn't on the calendar until…")
+  notice: z.string().max(400).default(''),
+  // replyTime and notice in each other site language
+  translations: z.record(RequestWords).default({}),
+  // the office phone, shown when requests are closed and on "Request sent"
+  phone: z.string().max(40).default(''),
+  // who hears about new requests; [] = acms({ members.notify }), else the owners
+  notify: z.array(z.string().max(254)).max(20).default([]),
+  // staff on that list who linked a phone also get a push (with no details)
+  phones: z.boolean().default(false),
+  // new requests a day from the app and the website together; 0 = no cap
+  perDay: z.number().int().min(0).max(10000).default(100),
+  // requests are deleted this many days after the answer (or after they arrived, if nobody answered)
+  keepDays: z.number().int().min(7).max(1095).default(180),
+});
+export type RequestSettings = z.infer<typeof RequestSettings>;
+
 export const CalendarSettings = z.object({
   // Display-only fallback: event covers remain empty until an image is explicitly chosen.
   eventFallbackImage: EventImageUrl.default(''),
@@ -663,6 +703,7 @@ export const CalendarSettings = z.object({
   approvalRules: ApprovalRules.default({}),
   // show bookings on the Schedule grid
   showBookings: z.boolean().default(true),
+  requests: RequestSettings.default({}),
 });
 export type CalendarSettings = z.infer<typeof CalendarSettings>;
 

package/src/pages/admin/calendar/events/index.astro

@@ -25,6 +25,7 @@ import { approveEventRequest, declineEventRequest, pendingRequests } from '../..
 import { approveDateRequest, dateRequestClashes, dateRequestTimes, declineDateRequest, type MoveRequestData } from '../../../../lib/calendar/host-requests';
 import { mergeEventDraft } from '../../../../lib/drafts';
 import { ApiError } from '../../../../lib/api';
+import { REQUESTS } from '../../../../lib/calendar/request-config';
 
 // Schedule → List: upcoming first, grouped by the month each event next
 // happens. Subscribed calendars appear as read-only rows with a "Make an
@@ -527,6 +528,7 @@ const subBits = [
               ))}
             </section>
           )}
+          {REQUESTS.enabled && <p class="hint">Every request, including those from the app and the website, is on <a href="/admin/calendar/requests">Requests</a>.</p>}
           {(requestRows.length > 0 || dateRows.length > 0) && !canApprove && <p class="hint">Someone whose role can publish content approves these.</p>}
           {canApprove && dateRows.map((r) => (
             <Modal id={`decline-date-${r.id}`} title="Decline this date change">