@byline/admin 4.14.1 → 4.15.0

package/dist/forms/scheduled-publication-control.js

@@ -0,0 +1,376 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useTranslation } from "@byline/i18n/react";
+import { Alert, Button, CloseIcon, DatePicker, IconButton, Label, Modal, Select } from "@byline/ui/react";
+import clsx from "clsx";
+import scheduled_publication_control_module from "./scheduled-publication-control.module.js";
+import { deriveScheduledPublicationState } from "./scheduled-publication-state.js";
+import { joinWallTime, resolveScheduledPublicationWallTime, wallTimeInZone } from "./scheduled-publication-time.js";
+const DUE_POLL_INTERVAL_MS = 30000;
+const DEFAULT_LEAD_MS = 900000;
+function browserTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+}
+function formatWallTime(wall, locale) {
+    const [year, month, day] = wall.date.split('-').map(Number);
+    if (null == year || null == month || null == day) return `${wall.date} ${wall.time}`;
+    if (Number.isNaN(year) || Number.isNaN(month) || Number.isNaN(day)) return `${wall.date} ${wall.time}`;
+    const dayLabel = new Intl.DateTimeFormat(locale, {
+        dateStyle: 'medium',
+        timeZone: 'UTC'
+    }).format(new Date(Date.UTC(year, month - 1, day, 12)));
+    return `${dayLabel}, ${wall.time}`;
+}
+function seedScheduleInstant(schedule) {
+    if (null != schedule) return new Date(schedule.publishAt);
+    const seed = new Date(Date.now() + DEFAULT_LEAD_MS);
+    seed.setSeconds(0, 0);
+    return seed;
+}
+function useScheduledPublication({ schedule, onSchedule, onConfirm, onCancel, hasUnsavedChanges, onUnsavedChanges }) {
+    const timeZone = useMemo(browserTimeZone, []);
+    const [now, setNow] = useState(()=>Date.now());
+    const [showSchedule, setShowSchedule] = useState(false);
+    const [busy, setBusy] = useState(false);
+    useEffect(()=>{
+        if (null == schedule) return;
+        const timer = setInterval(()=>setNow(Date.now()), DUE_POLL_INTERVAL_MS);
+        return ()=>clearInterval(timer);
+    }, [
+        schedule
+    ]);
+    const capabilities = useMemo(()=>({
+            canSchedule: null != onSchedule,
+            canConfirm: null != onConfirm,
+            canCancel: null != onCancel
+        }), [
+        onSchedule,
+        onConfirm,
+        onCancel
+    ]);
+    const state = useMemo(()=>deriveScheduledPublicationState(schedule, capabilities, now), [
+        schedule,
+        capabilities,
+        now
+    ]);
+    const openSchedule = useCallback(()=>{
+        if (hasUnsavedChanges) return void onUnsavedChanges();
+        setShowSchedule(true);
+    }, [
+        hasUnsavedChanges,
+        onUnsavedChanges
+    ]);
+    const confirm = useCallback(async ()=>{
+        if (null == onConfirm) return;
+        if (hasUnsavedChanges) return void onUnsavedChanges();
+        setBusy(true);
+        try {
+            await onConfirm();
+        } finally{
+            setBusy(false);
+        }
+    }, [
+        onConfirm,
+        hasUnsavedChanges,
+        onUnsavedChanges
+    ]);
+    const cancel = useCallback(async ()=>{
+        if (null == onCancel) return;
+        setBusy(true);
+        try {
+            await onCancel();
+        } finally{
+            setBusy(false);
+        }
+    }, [
+        onCancel
+    ]);
+    const modal = showSchedule ? /*#__PURE__*/ jsx(ScheduleModal, {
+        schedule: schedule,
+        timeZone: timeZone,
+        onSubmit: async (input)=>{
+            if (null == onSchedule) return;
+            setBusy(true);
+            try {
+                await onSchedule(input);
+                setShowSchedule(false);
+            } finally{
+                setBusy(false);
+            }
+        },
+        onDismiss: ()=>setShowSchedule(false),
+        busy: busy
+    }) : null;
+    return {
+        state,
+        timeZone,
+        busy,
+        isActive: 'none' !== state.kind || state.actions.schedule,
+        openSchedule,
+        confirm,
+        cancel,
+        modal
+    };
+}
+function useInstantFormatter(timeZone) {
+    const { locale } = useTranslation('byline-admin');
+    return useMemo(()=>new Intl.DateTimeFormat(locale, {
+            dateStyle: 'medium',
+            timeStyle: 'short',
+            timeZone
+        }), [
+        locale,
+        timeZone
+    ]);
+}
+function ScheduledPublicationCell({ state, timeZone }) {
+    const { t } = useTranslation('byline-admin');
+    const format = useInstantFormatter(timeZone);
+    if ('armed' !== state.kind || null == state.publishAt) return null;
+    return /*#__PURE__*/ jsx("time", {
+        className: clsx('byline-scheduled-publication-cell', scheduled_publication_control_module.cell),
+        dateTime: state.publishAt.toISOString(),
+        children: t('scheduledPublication.status.cellText', {
+            dateTime: `${format.format(state.publishAt)} (${timeZone})`
+        })
+    });
+}
+function ScheduledPublicationNotice({ state, timeZone, busy, onConfirm, onReschedule, onCancel }) {
+    const { t } = useTranslation('byline-admin');
+    const format = useInstantFormatter(timeZone);
+    if (!state.isExceptional || null == state.publishAt) return null;
+    const instant = `${format.format(state.publishAt)} (${timeZone})`;
+    const title = 'needs_reconfirm' === state.kind ? t('scheduledPublication.status.needsReconfirm') : t('scheduledPublication.status.overdue');
+    return /*#__PURE__*/ jsx("div", {
+        role: "region",
+        "aria-label": title,
+        children: /*#__PURE__*/ jsxs(Alert, {
+            className: clsx('byline-scheduled-publication-notice', scheduled_publication_control_module.notice),
+            intent: 'danger' === state.tone ? 'danger' : 'warning',
+            icon: true,
+            close: false,
+            title: title,
+            children: [
+                /*#__PURE__*/ jsx("p", {
+                    className: scheduled_publication_control_module["notice-body"],
+                    children: 'needs_reconfirm' === state.kind ? t('scheduledPublication.status.contentChanged') : t('scheduledPublication.status.overdueBody')
+                }),
+                /*#__PURE__*/ jsxs("p", {
+                    className: scheduled_publication_control_module["notice-instant"],
+                    children: [
+                        t('scheduledPublication.status.authorizedFor', {
+                            dateTime: instant
+                        }),
+                        'needs_reconfirm' === state.kind && state.isPastDue && /*#__PURE__*/ jsxs(Fragment, {
+                            children: [
+                                " ",
+                                t('scheduledPublication.status.pastDueNote')
+                            ]
+                        })
+                    ]
+                }),
+                state.attemptCount > 0 && /*#__PURE__*/ jsx("p", {
+                    className: scheduled_publication_control_module["notice-attempts"],
+                    children: t('scheduledPublication.status.attempts', {
+                        count: state.attemptCount
+                    })
+                }),
+                null != state.lastError && /*#__PURE__*/ jsx("p", {
+                    className: scheduled_publication_control_module["notice-error"],
+                    children: state.lastError
+                }),
+                /*#__PURE__*/ jsxs("div", {
+                    className: clsx('byline-scheduled-publication-notice-actions', scheduled_publication_control_module["notice-actions"]),
+                    children: [
+                        state.actions.confirm && /*#__PURE__*/ jsx(Button, {
+                            size: "sm",
+                            type: "button",
+                            intent: "success",
+                            disabled: busy,
+                            onClick: onConfirm,
+                            children: t('scheduledPublication.actions.confirm')
+                        }),
+                        state.actions.reschedule && /*#__PURE__*/ jsx(Button, {
+                            size: "sm",
+                            type: "button",
+                            intent: "info",
+                            disabled: busy,
+                            onClick: onReschedule,
+                            children: t('scheduledPublication.actions.reschedule')
+                        }),
+                        state.actions.cancel && /*#__PURE__*/ jsx(Button, {
+                            size: "sm",
+                            type: "button",
+                            variant: "text",
+                            disabled: busy,
+                            onClick: onCancel,
+                            children: t('scheduledPublication.actions.cancel')
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+}
+function ScheduleModal({ schedule, timeZone, onSubmit, onDismiss, busy }) {
+    const { t, locale } = useTranslation('byline-admin');
+    const [seedInstant] = useState(()=>seedScheduleInstant(schedule));
+    const [today] = useState(()=>new Date());
+    const [wall, setWall] = useState(()=>wallTimeInZone(seedInstant, timeZone));
+    const [instantChoices, setInstantChoices] = useState([]);
+    const [selectedInstant, setSelectedInstant] = useState('');
+    const [validationError, setValidationError] = useState(null);
+    const resetResolution = ()=>{
+        setInstantChoices([]);
+        setSelectedInstant('');
+        setValidationError(null);
+    };
+    const submit = async ()=>{
+        const value = joinWallTime(wall);
+        if (null == value) return void setValidationError(t('scheduledPublication.form.invalid'));
+        const resolution = resolveScheduledPublicationWallTime(value, timeZone);
+        if ('invalid' === resolution.status) return void setValidationError(t('scheduledPublication.form.invalid'));
+        const offending = formatWallTime(wall, locale);
+        if ('nonexistent' === resolution.status) return void setValidationError(t('scheduledPublication.form.nonexistent', {
+            wallTime: offending
+        }));
+        if (resolution.choices.length > 1 && !resolution.choices.some((c)=>c.iso === selectedInstant)) {
+            setInstantChoices(resolution.choices);
+            setValidationError(t('scheduledPublication.form.ambiguous', {
+                wallTime: offending
+            }));
+            return;
+        }
+        const publishAtIso = selectedInstant || resolution.choices[0]?.iso;
+        if (null == publishAtIso) return;
+        if (Date.parse(publishAtIso) <= Date.now()) return void setValidationError(t('scheduledPublication.form.notFuture', {
+            wallTime: offending
+        }));
+        await onSubmit({
+            publishAt: publishAtIso
+        });
+    };
+    const title = null == schedule ? t('scheduledPublication.form.scheduleTitle') : t('scheduledPublication.form.rescheduleTitle');
+    return /*#__PURE__*/ jsx(Modal, {
+        isOpen: true,
+        closeOnOverlayClick: !busy,
+        onDismiss: ()=>{
+            if (!busy) onDismiss();
+        },
+        children: /*#__PURE__*/ jsxs(Modal.Container, {
+            style: {
+                maxWidth: '560px'
+            },
+            children: [
+                /*#__PURE__*/ jsxs(Modal.Header, {
+                    className: scheduled_publication_control_module.modalHead,
+                    children: [
+                        /*#__PURE__*/ jsx("h3", {
+                            className: scheduled_publication_control_module.modalTitle,
+                            children: title
+                        }),
+                        /*#__PURE__*/ jsx(IconButton, {
+                            "aria-label": t('common.actions.close'),
+                            size: "xs",
+                            disabled: busy,
+                            onClick: onDismiss,
+                            children: /*#__PURE__*/ jsx(CloseIcon, {
+                                width: "16px",
+                                height: "16px",
+                                svgClassName: "white-icon"
+                            })
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsxs(Modal.Content, {
+                    children: [
+                        /*#__PURE__*/ jsx("div", {
+                            className: scheduled_publication_control_module.field,
+                            children: /*#__PURE__*/ jsx(DatePicker, {
+                                id: "scheduled-publication-at",
+                                name: "scheduled-publication-at",
+                                label: t('scheduledPublication.form.dateTime'),
+                                mode: "datetime",
+                                inputSize: "sm",
+                                minDate: today,
+                                yearsInPast: 0,
+                                yearsInFuture: 5,
+                                initialValue: seedInstant,
+                                onWallTimeChange: (value)=>{
+                                    if (null == value) return;
+                                    setWall(value);
+                                    resetResolution();
+                                }
+                            })
+                        }),
+                        /*#__PURE__*/ jsx("p", {
+                            className: scheduled_publication_control_module.help,
+                            children: t('scheduledPublication.form.timeZone', {
+                                timeZone
+                            })
+                        }),
+                        instantChoices.length > 1 && /*#__PURE__*/ jsxs("div", {
+                            className: scheduled_publication_control_module.choice,
+                            children: [
+                                /*#__PURE__*/ jsx(Label, {
+                                    id: "scheduled-publication-offset-label",
+                                    htmlFor: "scheduled-publication-offset",
+                                    label: t('scheduledPublication.form.offset')
+                                }),
+                                /*#__PURE__*/ jsx(Select, {
+                                    id: "scheduled-publication-offset",
+                                    name: "scheduled-publication-offset",
+                                    ariaLabel: t('scheduledPublication.form.offset'),
+                                    containerClassName: scheduled_publication_control_module["choice-select"],
+                                    placeholder: t('scheduledPublication.form.offsetPlaceholder'),
+                                    size: "sm",
+                                    value: selectedInstant,
+                                    items: instantChoices.map((choice, index)=>({
+                                            value: choice.iso,
+                                            label: t(0 === index ? 'scheduledPublication.form.offsetEarlier' : 'scheduledPublication.form.offsetLater', {
+                                                offset: choice.offsetLabel
+                                            })
+                                        })),
+                                    onValueChange: (value)=>{
+                                        setSelectedInstant(value ?? '');
+                                        setValidationError(null);
+                                    },
+                                    disabled: busy
+                                })
+                            ]
+                        }),
+                        null != validationError && /*#__PURE__*/ jsx("p", {
+                            className: scheduled_publication_control_module.validation,
+                            role: "alert",
+                            children: validationError
+                        }),
+                        /*#__PURE__*/ jsx("p", {
+                            className: scheduled_publication_control_module.warningText,
+                            children: t('scheduledPublication.form.editWarning')
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsxs(Modal.Actions, {
+                    children: [
+                        /*#__PURE__*/ jsx(Button, {
+                            size: "sm",
+                            intent: "noeffect",
+                            disabled: busy,
+                            onClick: onDismiss,
+                            children: t('common.actions.cancel')
+                        }),
+                        /*#__PURE__*/ jsx(Button, {
+                            size: "sm",
+                            intent: "primary",
+                            disabled: busy || 0 === wall.date.length || 0 === wall.time.length,
+                            onClick: submit,
+                            children: busy ? t('scheduledPublication.form.saving') : null == schedule ? t('scheduledPublication.actions.schedule') : t('scheduledPublication.actions.reschedule')
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+}
+export { ScheduledPublicationCell, ScheduledPublicationNotice, useScheduledPublication };

package/dist/forms/scheduled-publication-control.module.js

@@ -0,0 +1,25 @@
+import "./scheduled-publication-control_module.css";
+const scheduled_publication_control_module = {
+    cell: "cell-PLfZ8N",
+    notice: "notice-a85M8d",
+    "notice-body": "notice-body-I7ZQZ6",
+    noticeBody: "notice-body-I7ZQZ6",
+    "notice-instant": "notice-instant-vUk7Iz",
+    noticeInstant: "notice-instant-vUk7Iz",
+    "notice-attempts": "notice-attempts-lqDFQZ",
+    noticeAttempts: "notice-attempts-lqDFQZ",
+    "notice-error": "notice-error-b8EmB9",
+    noticeError: "notice-error-b8EmB9",
+    "notice-actions": "notice-actions-dDHhl_",
+    noticeActions: "notice-actions-dDHhl_",
+    modalHead: "modalHead-sE__5Y",
+    modalTitle: "modalTitle-NXtMjb",
+    field: "field-Z0Zwaq",
+    help: "help-UVZDXJ",
+    validation: "validation-ThnwlW",
+    warningText: "warningText-zXrWei",
+    choice: "choice-aTHmEn",
+    "choice-select": "choice-select-fA1Bvp",
+    choiceSelect: "choice-select-fA1Bvp"
+};
+export default scheduled_publication_control_module;

package/dist/forms/scheduled-publication-control_module.css

@@ -0,0 +1,95 @@
+.cell-PLfZ8N {
+  color: var(--text-success);
+  overflow-wrap: anywhere;
+  white-space: normal;
+  flex-basis: 100%;
+  font-weight: 600;
+}
+
+@media (min-width: 66rem) {
+  .cell-PLfZ8N {
+    margin-left: var(--spacing-4);
+    flex-basis: auto;
+  }
+
+  .byline-form-status-cell:has( > .cell-PLfZ8N) {
+    align-items: flex-start;
+  }
+}
+
+.notice-a85M8d {
+  margin-top: var(--spacing-8);
+  margin-bottom: var(--spacing-8);
+}
+
+.notice-body-I7ZQZ6, .notice-instant-vUk7Iz, .notice-attempts-lqDFQZ, .notice-error-b8EmB9 {
+  margin: 0 0 var(--spacing-4);
+  font-size: var(--font-size-sm);
+}
+
+.notice-instant-vUk7Iz {
+  font-weight: 600;
+}
+
+.notice-attempts-lqDFQZ {
+  color: var(--gray-500);
+}
+
+.notice-error-b8EmB9 {
+  font-family: var(--font-family-mono, monospace);
+  overflow-wrap: anywhere;
+}
+
+.notice-actions-dDHhl_ {
+  align-items: center;
+  gap: var(--spacing-8);
+  margin-top: var(--spacing-8);
+  flex-wrap: wrap;
+  display: flex;
+}
+
+.modalHead-sE__5Y {
+  margin-bottom: var(--spacing-8);
+  padding-top: 1rem;
+}
+
+.modalTitle-NXtMjb {
+  margin: 0 0 var(--spacing-8) 0;
+  font-size: var(--font-size-2xl);
+}
+
+.field-Z0Zwaq {
+  display: block;
+}
+
+.help-UVZDXJ, .validation-ThnwlW, .warningText-zXrWei {
+  font-size: var(--font-size-sm);
+}
+
+.help-UVZDXJ {
+  margin: var(--spacing-4) 0 0;
+}
+
+.warningText-zXrWei {
+  margin: var(--spacing-12) 0 0;
+  color: var(--gray-500);
+}
+
+.validation-ThnwlW {
+  margin: var(--spacing-8) 0 0;
+  color: var(--red-600);
+}
+
+.choice-aTHmEn {
+  margin-top: var(--spacing-12);
+}
+
+.choice-select-fA1Bvp {
+  min-width: 16rem;
+  max-width: 100%;
+}
+
+:is([data-theme="dark"], .dark) .validation-ThnwlW {
+  color: var(--red-400, #f87171);
+}
+

package/dist/forms/scheduled-publication-state.d.ts

@@ -0,0 +1,83 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * Presentation state for a document's pending publication schedule.
+ *
+ * The editor surfaces four situations, and they differ in how loudly they
+ * should be presented, not just in wording:
+ *
+ *   - `none`            — nothing scheduled; only the "schedule" action applies.
+ *   - `armed`           — a future instant is authorized against a reviewed
+ *                         version. Quiet: a metadata cell in the status bar.
+ *   - `needs_reconfirm` — content was saved after the time was authorized, so
+ *                         the schedule is suspended until an editor reviews and
+ *                         confirms the current version. Loud, and durable: this
+ *                         has to stay discoverable long after the toast is gone.
+ *   - `overdue`         — armed, due, and not yet finalized. The sweep may still
+ *                         be retrying, and `lastError` may carry a bounded
+ *                         reason. Loud.
+ *
+ * Deriving this in one pure place keeps the branching out of the components and
+ * makes the awkward combinations (a suspended schedule whose instant has also
+ * passed; an overdue schedule the actor may not cancel) testable without a DOM.
+ */
+export type ScheduledPublicationStateKind = 'none' | 'armed' | 'needs_reconfirm' | 'overdue';
+/** How prominently the state should be rendered. */
+export type ScheduledPublicationTone = 'neutral' | 'info' | 'warning' | 'danger';
+export interface ScheduledPublicationInfo {
+    publishAt: string | Date;
+    targetVersionId: string;
+    state: 'armed' | 'needs_reconfirm';
+    lastAuthorizedBy: string | null;
+    lastError: string | null;
+    nextAttemptAt: string | Date;
+    attemptCount: number;
+}
+/**
+ * Which operations the host has wired up for this document and actor. A
+ * missing handler means the actor cannot perform the operation — the server
+ * decides, and the editor never renders an action it cannot complete.
+ */
+export interface ScheduledPublicationCapabilities {
+    canSchedule: boolean;
+    canConfirm: boolean;
+    canCancel: boolean;
+}
+export interface ScheduledPublicationState {
+    kind: ScheduledPublicationStateKind;
+    tone: ScheduledPublicationTone;
+    /** The authorized instant, or null when nothing is scheduled. */
+    publishAt: Date | null;
+    /**
+     * True when the authorized instant has passed. Tracked separately from
+     * `kind` so a suspended schedule that is also past due still reads as
+     * "needs re-confirmation" — the reason it did not publish — while the
+     * elapsed time remains available to the summary.
+     */
+    isPastDue: boolean;
+    /** Bounded failure reason from the last sweep attempt, when the server sent one. */
+    lastError: string | null;
+    /** Sweep attempts so far. Only meaningful once the instant has passed. */
+    attemptCount: number;
+    /** True when the state warrants an escalated, dismissible-proof notice rather than a metadata cell. */
+    isExceptional: boolean;
+    actions: {
+        schedule: boolean;
+        reschedule: boolean;
+        confirm: boolean;
+        cancel: boolean;
+    };
+}
+/**
+ * Derive the editor's presentation state from the server's schedule record.
+ *
+ * `now` is injected rather than read from the clock so the boundary between
+ * armed and overdue is testable, and so a single render pass cannot disagree
+ * with itself.
+ */
+export declare function deriveScheduledPublicationState(schedule: ScheduledPublicationInfo | null, capabilities: ScheduledPublicationCapabilities, now: number): ScheduledPublicationState;

package/dist/forms/scheduled-publication-state.js

@@ -0,0 +1,41 @@
+function toDate(value) {
+    return value instanceof Date ? value : new Date(value);
+}
+function deriveScheduledPublicationState(schedule, capabilities, now) {
+    if (null == schedule) return {
+        kind: 'none',
+        tone: 'neutral',
+        publishAt: null,
+        isPastDue: false,
+        lastError: null,
+        attemptCount: 0,
+        isExceptional: false,
+        actions: {
+            schedule: capabilities.canSchedule,
+            reschedule: false,
+            confirm: false,
+            cancel: false
+        }
+    };
+    const publishAt = toDate(schedule.publishAt);
+    const isPastDue = Number.isFinite(publishAt.getTime()) && publishAt.getTime() <= now;
+    const needsReconfirm = 'needs_reconfirm' === schedule.state;
+    const kind = needsReconfirm ? 'needs_reconfirm' : isPastDue ? 'overdue' : 'armed';
+    const tone = null != schedule.lastError ? 'danger' : 'armed' === kind ? 'info' : 'warning';
+    return {
+        kind,
+        tone,
+        publishAt,
+        isPastDue,
+        lastError: schedule.lastError,
+        attemptCount: schedule.attemptCount,
+        isExceptional: 'armed' !== kind,
+        actions: {
+            schedule: false,
+            reschedule: capabilities.canSchedule,
+            confirm: needsReconfirm && capabilities.canConfirm,
+            cancel: capabilities.canCancel
+        }
+    };
+}
+export { deriveScheduledPublicationState };

package/dist/forms/scheduled-publication-state.test.node.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};

package/dist/forms/scheduled-publication-time.d.ts

@@ -0,0 +1,57 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export interface ScheduledPublicationInstantChoice {
+    iso: string;
+    offsetLabel: string;
+}
+/**
+ * A wall time as the editor sees it: a calendar day and a clock reading, with
+ * no instant attached yet.
+ *
+ * The schedule modal takes these two halves from the date picker's
+ * `onWallTimeChange` and keeps them as strings all the way to
+ * `resolveScheduledPublicationWallTime`, never routing them through a `Date`.
+ * That is deliberate: `setHours` silently normalizes a nonexistent wall time (a
+ * spring-forward 02:30 becomes 03:30) and silently picks the first of two
+ * ambiguous instants at a fall-back overlap. Both are exactly the cases the
+ * editor has to be asked about, so the only safe carrier between the picker and
+ * the resolver is text.
+ */
+export interface ScheduledPublicationWallTime {
+    /** Calendar day as `YYYY-MM-DD`. */
+    date: string;
+    /** Clock reading as `HH:mm`, 24-hour. */
+    time: string;
+}
+export type ScheduledPublicationWallTimeResolution = {
+    status: 'invalid';
+} | {
+    status: 'nonexistent';
+} | {
+    status: 'valid';
+    choices: ScheduledPublicationInstantChoice[];
+};
+/**
+ * Resolve a browser-entered wall time in an explicit IANA zone. Returns no
+ * choice for a daylight-saving gap and two choices for an overlap, forcing
+ * the editor to choose an actual instant rather than accepting JS Date's
+ * silent normalization.
+ */
+export declare function resolveScheduledPublicationWallTime(value: string, timeZone: string): ScheduledPublicationWallTimeResolution;
+/**
+ * Split an instant into the calendar day and clock reading it shows in
+ * `timeZone`. Used to seed the modal when rescheduling, so the editor starts
+ * from the time they authorized rather than from its UTC spelling.
+ */
+export declare function wallTimeInZone(instant: Date, timeZone: string): ScheduledPublicationWallTime;
+/**
+ * Join a wall time back into the `YYYY-MM-DDTHH:mm` string that
+ * `resolveScheduledPublicationWallTime` parses. Returns null when either half
+ * is still blank, which is the modal's "nothing to validate yet" signal.
+ */
+export declare function joinWallTime(wall: ScheduledPublicationWallTime): string | null;