@superpanel-sdk/runtime 0.2.3 → 0.7.0

package/dist/core/functions/errors.d.ts

@@ -0,0 +1,74 @@
+import type { PageTablesDesc } from '../page/typed.js';
+import type { ExchangeRef } from '../context/exchanges.js';
+import type { Ctx } from './types.js';
+/**
+ * Errors of the company's code (67): a failure its code did not catch (a throw, its time or memory up), or
+ * a text or email conversation the AI marked stuck, is recorded once and the company's `onError` (root
+ * `errors.ts`) runs for it, in the background. What happens at the moment is the platform's and depends
+ * only on the channel (67 §3). The company does not throw errors of its own: what its code foresees, it
+ * handles where it happens. The platform's own failures are the platform's, not the company's (67 §4.4).
+ */
+/** The module at the repository root `onError` is exported from. */
+export declare const ERRORS_MODULE = "errors";
+/** `onError`'s name in the company build's function registry. */
+export declare const ON_ERROR_FUNCTION = "onError";
+/**
+ * `crash` an uncaught throw, `timeout` / `memory` the call's limit, `stuck` the AI marked a text or email
+ * conversation stuck, `platform` the platform failed and what the code was doing was not done (74 §3.2: an
+ * Orchestrator run the platform cut off or could not run, or a {@link PlatformUnavailableError} not caught).
+ */
+export type CodeErrorKind = 'crash' | 'timeout' | 'memory' | 'stuck' | 'platform';
+/** What the company is told of a `platform` error (74 §3.2): the platform's own failure stays in its logs and alerts. */
+export declare const PLATFORM_UNAVAILABLE_MESSAGE = "The platform was temporarily unavailable; we have been alerted.";
+/**
+ * A `ctx.api` call the platform could not answer (74 §3.2): it was unreachable, or failed on its side, after
+ * the tries it was worth. Not caught, it is a `platform` error (we are alerted, `onError` is told); caught and
+ * thrown again as another error, it is the code's own.
+ */
+export declare class PlatformUnavailableError extends Error {
+    readonly name = "PlatformUnavailableError";
+    /** The platform's refusal reason, when it gave one (`error.code`, as on any `ctx.api` error). */
+    code?: string;
+}
+/** What failed: the kind of entry, and its name (a function's, an event's, a job's, the page's `render` / `start` / `action:<name>`). */
+export type CodeErrorSourceType = 'resolve' | 'page' | 'function' | 'event' | 'orchestrator' | 'schedule' | 'webhook' | 'conversation';
+/** At most this much JSON for `args` (67 §4.2): bigger is cut, and says so. */
+export declare const ERROR_JSON_MAX_BYTES: number;
+/** One error, as `onError` gets it (`args.error`). */
+export type CodeErrorEvent = {
+    /** The error's id: find it in the error view, say it to the platform's team. */
+    id: string;
+    kind: CodeErrorKind;
+    message: string;
+    /** Where your code threw, in your files; none for `timeout`, `memory`, `stuck`, `platform`. */
+    stack?: string;
+    source: {
+        type: CodeErrorSourceType;
+        name: string;
+    };
+    /** The published company build whose code ran; null when a repository was being served. */
+    buildId: string | null;
+    at: string;
+    ids: {
+        sequenceId?: string;
+        instanceId?: string;
+        contactId?: string;
+        runId?: string;
+    };
+    /** Who is waiting: the call (it was already ended), or a text's or email's exchange and what the customer sent. */
+    channel?: {
+        type: 'call';
+        callId?: string;
+    } | {
+        type: 'sms' | 'email';
+        exchange?: ExchangeRef;
+        waiting: string;
+    };
+    /** The arguments of the call that failed (cut at {@link ERROR_JSON_MAX_BYTES}). */
+    args?: unknown;
+};
+/** `onError` of `errors.ts`: `(ctx, { error })`, run once for each error, with no case. */
+export type OnError<D extends PageTablesDesc | undefined = undefined> = (ctx: Ctx<D>, args: {
+    error: CodeErrorEvent;
+}) => Promise<void>;
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/functions/errors.js

@@ -0,0 +1,26 @@
+/**
+ * Errors of the company's code (67): a failure its code did not catch (a throw, its time or memory up), or
+ * a text or email conversation the AI marked stuck, is recorded once and the company's `onError` (root
+ * `errors.ts`) runs for it, in the background. What happens at the moment is the platform's and depends
+ * only on the channel (67 §3). The company does not throw errors of its own: what its code foresees, it
+ * handles where it happens. The platform's own failures are the platform's, not the company's (67 §4.4).
+ */
+/** The module at the repository root `onError` is exported from. */
+export const ERRORS_MODULE = 'errors';
+/** `onError`'s name in the company build's function registry. */
+export const ON_ERROR_FUNCTION = 'onError';
+/** What the company is told of a `platform` error (74 §3.2): the platform's own failure stays in its logs and alerts. */
+export const PLATFORM_UNAVAILABLE_MESSAGE = 'The platform was temporarily unavailable; we have been alerted.';
+/**
+ * A `ctx.api` call the platform could not answer (74 §3.2): it was unreachable, or failed on its side, after
+ * the tries it was worth. Not caught, it is a `platform` error (we are alerted, `onError` is told); caught and
+ * thrown again as another error, it is the code's own.
+ */
+export class PlatformUnavailableError extends Error {
+    name = 'PlatformUnavailableError';
+    /** The platform's refusal reason, when it gave one (`error.code`, as on any `ctx.api` error). */
+    code;
+}
+/** At most this much JSON for `args` (67 §4.2): bigger is cut, and says so. */
+export const ERROR_JSON_MAX_BYTES = 16 * 1024;
+//# sourceMappingURL=errors.js.map

package/dist/core/functions/events.d.ts

@@ -0,0 +1,192 @@
+import { z } from 'zod';
+import type { Id, PageTablesDesc } from '../page/typed.js';
+import type { Ctx } from './types.js';
+/**
+ * Platform events.
+ *
+ * The event name is the key of the company `events` export. For every event the
+ * platform fixes the payload and the return type (`void` for every event; `webhook.received`, a
+ * function of its own, returns a {@link WebhookOutcome}) — companies only choose which events to
+ * subscribe to.
+ *
+ * A handler is a function like any other (38 §2.2): `(ctx, { event, subject, instanceId })`, the
+ * company's own code, not the conversation's: it does not get the page. It reads and writes with
+ * `ctx.api.db`.
+ *
+ * Payloads are provider-neutral on purpose: Twilio / Gmail vocabulary is
+ * translated in the channel adapter, never carried into these types.
+ */
+/** Shared by every call event. `id` can be passed directly to `ctx.api.call.get`. */
+export type CallEventBase = {
+    id: string;
+    /** Provider-neutral name for the channel-native id (voice: Twilio CallSid). */
+    externalId: string;
+    fromNumber: string;
+    toNumber: string;
+};
+export type CallInboundEvent = CallEventBase & {
+    startedAt: string;
+};
+export type CallOutboundEvent = CallEventBase & {
+    startedAt: string;
+};
+export type CallEndedEvent = CallEventBase & {
+    /** Provider-neutral terminal outcome. */
+    outcome: 'completed' | 'busy' | 'failed' | 'no-answer' | 'canceled';
+    durationSec: number | null;
+};
+/** Shared by every SMS event. `id` can be passed directly to `ctx.api.sms.get`. */
+export type SmsEventBase = {
+    id: string;
+    fromNumber: string;
+    toNumber: string;
+    body: string;
+};
+export type SmsReceivedEvent = SmsEventBase & {
+    receivedAt: string;
+};
+export type SmsSendRequestedEvent = SmsEventBase & {
+    requestedAt: string;
+};
+/** Shared by every email event. `id` can be passed directly to `ctx.api.email.get`. */
+export type EmailEventBase = {
+    id: string;
+    /** The provider's thread id (null for a thread we start, until its first email went). */
+    threadId: string | null;
+    fromAddress: string;
+    toAddresses: string[];
+    subject: string | null;
+    body: string | null;
+};
+export type EmailReceivedEvent = EmailEventBase & {
+    receivedAt: string;
+};
+export type EmailSendRequestedEvent = EmailEventBase & {
+    requestedAt: string;
+};
+/**
+ * The HTTP request exactly as the gateway saw it. The platform verifies nothing: every header,
+ * the absolute URL and the raw body are forwarded so the handler can check the sender's signature.
+ */
+export type WebhookRequest = {
+    method: 'GET' | 'POST' | 'PUT';
+    /** Absolute URL as the sender saw it (`https://…/webhook/e/<code>/lead/created?x=1`); signatures are usually computed over it. */
+    url: string;
+    /** Sub-path after the webhook code: `/webhook/e/<code>/lead/created` → `lead/created`; `''` when absent. */
+    path: string;
+    query: Record<string, string>;
+    /** Every request header, lower-cased names, multi-valued headers joined with `, `. Nothing is removed. */
+    headers: Record<string, string>;
+    contentType: string | null;
+    /** Raw body text, always present (empty string for GET). */
+    body: string;
+};
+/**
+ * One inbound request to one of the environment's webhook URLs (made on the Webhooks page). The
+ * platform routes, stores and forwards it; it does not verify it and knows nothing
+ * about the sender's event model. The company's `webhook.ts` decides whether the request is genuine
+ * and answers with a {@link WebhookOutcome} (22-sequence-as-business-unit §9).
+ */
+export type WebhookEvent = {
+    /** Delivery id. Stable across retries: use it as an idempotency key and to find the row in Trigger history. */
+    id: string;
+    receivedAt: string;
+    /** 1 on the first run, higher on worker retries. */
+    attempt: number;
+    /**
+     * Which webhook URL received it: `name` is the URL's name on the Webhooks page (the same in test and
+     * prod).
+     */
+    webhook: {
+        id: string;
+        name: string;
+    };
+    /**
+     * Body parsed by Content-Type: JSON → the parsed value (object, array or scalar);
+     * form-urlencoded → flat object; anything else → null. `request.body` always has the raw text.
+     */
+    payload: unknown;
+    request: WebhookRequest;
+};
+/**
+ * What `webhook.received` must return. Explicit on purpose: a plain `return` is a type error.
+ * - `accepted`: the request was genuine and handled; the delivery is marked succeeded.
+ * - `rejected`: the handler's own verification failed (bad signature, unknown sender, …); the
+ *   delivery is marked rejected with `reason` and is never retried.
+ * Throwing means "something went wrong on our side": the delivery is marked failed and retried.
+ */
+export type WebhookOutcome = {
+    status: 'accepted';
+} | {
+    status: 'rejected';
+    reason: string;
+};
+/** Wire schema of {@link WebhookOutcome}; the worker validates the handler's return with it. */
+export declare const webhookOutcome: z.ZodType<WebhookOutcome>;
+/** Event name → { payload, handler return }. */
+export type SystemEventMap = {
+    'call.inbound': {
+        event: CallInboundEvent;
+        result: void;
+    };
+    'call.outbound': {
+        event: CallOutboundEvent;
+        result: void;
+    };
+    'call.ended': {
+        event: CallEndedEvent;
+        result: void;
+    };
+    'sms.received': {
+        event: SmsReceivedEvent;
+        result: void;
+    };
+    'sms.send-requested': {
+        event: SmsSendRequestedEvent;
+        result: void;
+    };
+    'email.received': {
+        event: EmailReceivedEvent;
+        result: void;
+    };
+    'email.send-requested': {
+        event: EmailSendRequestedEvent;
+        result: void;
+    };
+};
+export type SystemEventName = keyof SystemEventMap;
+export type SystemEventPayload<K extends SystemEventName> = SystemEventMap[K]['event'];
+export type SystemEventResult<K extends SystemEventName> = SystemEventMap[K]['result'];
+/** Runtime table mirroring {@link SystemEventMap}: the events a handler may be written for. */
+export declare const SYSTEM_EVENTS: {
+    readonly [K in SystemEventName]: true;
+};
+export declare const SYSTEM_EVENT_NAMES: readonly SystemEventName[];
+export declare function isSystemEventName(value: string): value is SystemEventName;
+/** What a handler is called with (38 §2.2): the event, and the instance it is on and its business root. */
+export type EventHandlerArgs<K extends SystemEventName, S extends string = string> = {
+    event: SystemEventPayload<K>;
+    subject: Id<S>;
+    instanceId: string;
+};
+/** Handler for one event: `(ctx, { event, subject, instanceId })`; `D` types `ctx.api.db`, `S` the business root. */
+export type EventHandler<K extends SystemEventName, D extends PageTablesDesc | undefined = undefined, S extends string = string> = (ctx: Ctx<D>, args: EventHandlerArgs<K, S>) => Promise<SystemEventResult<K>>;
+/** Company `events` export: subscribe to any subset of platform events. */
+export type EventHandlers<D extends PageTablesDesc | undefined = undefined, S extends string = string> = {
+    [K in SystemEventName]?: EventHandler<K, D, S>;
+};
+/** Loader/host-side view of an events map: handler argument types are not known. */
+export type AnyEventHandlers = {
+    [K in SystemEventName]?: (ctx: any, args: any) => Promise<unknown>;
+};
+/** The company function that receives webhooks: `received` of `webhook.ts` at the repository root. */
+export declare const WEBHOOK_RECEIVED_FUNCTION = "webhook.received";
+/**
+ * `received` of `webhook.ts` (22 §9): every webhook of the environment comes here, told apart by
+ * `event.webhook.name`. It runs with no sequence; to hand a request to one, start an instance or call
+ * its code through the platform API. Return accepted / rejected explicitly; throw to be retried.
+ */
+export type WebhookHandler<D extends PageTablesDesc | undefined = undefined> = (ctx: Ctx<D>, args: {
+    event: WebhookEvent;
+}) => Promise<WebhookOutcome>;
+//# sourceMappingURL=events.d.ts.map

package/dist/core/functions/events.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+/** Wire schema of {@link WebhookOutcome}; the worker validates the handler's return with it. */
+export const webhookOutcome = z.discriminatedUnion('status', [
+    z.object({ status: z.literal('accepted') }),
+    z.object({ status: z.literal('rejected'), reason: z.string() }),
+]);
+/** Runtime table mirroring {@link SystemEventMap}: the events a handler may be written for. */
+export const SYSTEM_EVENTS = {
+    'call.inbound': true,
+    'call.outbound': true,
+    'call.ended': true,
+    'sms.received': true,
+    'sms.send-requested': true,
+    'email.received': true,
+    'email.send-requested': true,
+};
+export const SYSTEM_EVENT_NAMES = Object.keys(SYSTEM_EVENTS);
+export function isSystemEventName(value) {
+    return Object.hasOwn(SYSTEM_EVENTS, value);
+}
+/** The company function that receives webhooks: `received` of `webhook.ts` at the repository root. */
+export const WEBHOOK_RECEIVED_FUNCTION = 'webhook.received';
+//# sourceMappingURL=events.js.map

package/dist/core/functions/schedules.d.ts

@@ -0,0 +1,50 @@
+import type { PageTablesDesc } from '../page/typed.js';
+import type { Ctx } from './types.js';
+/**
+ * Recurring jobs (25 §6.4): `schedules.ts` at the repository root, next to `webhook.ts`; the
+ * company's only (a sequence has none). Each runs on its cron in every environment
+ * whose live release has it, with no case and no contact; `ctx.api` is the webhook handler's
+ * (`db`, `integration`, `instances.start`, `instances.notify`, `log`, `kv`).
+ */
+/** What a job's `run` is told (`args.schedule`): which job, and the tick it runs for. */
+export type ScheduleTick = {
+    /** The job's key in `defineSchedules({ … })`. */
+    name: string;
+    cron: string;
+    timezone: string;
+    /** The tick this run is for (ISO). A run made up after the worker was down has the missed tick's time. */
+    scheduledAt: string;
+};
+export type ScheduleDefinition<D extends PageTablesDesc | undefined = undefined> = {
+    /** Five fields: minute hour day-of-month month day-of-week (`'0 2 * * *'`: every day at 02:00). */
+    cron: string;
+    /** IANA name the cron is read in (`'UTC'`, `'America/Phoenix'`). */
+    timezone: string;
+    /** Throw to have the run recorded as failed; it is not retried, the next tick runs as usual. */
+    run: (ctx: Ctx<D>, args: {
+        schedule: ScheduleTick;
+    }) => Promise<void>;
+};
+/** The `schedules` export: job name → definition. */
+export type Schedules<D extends PageTablesDesc | undefined = undefined> = Record<string, ScheduleDefinition<D>>;
+/**
+ * Author-side helper for `schedules.ts`:
+ *
+ * ```ts
+ * export const schedules = defineSchedules({
+ *   nightlySync: { cron: '0 2 * * *', timezone: 'UTC', run: async (ctx, { schedule }) => { … } },
+ * });
+ * ```
+ */
+export declare function defineSchedules<D extends PageTablesDesc | undefined = undefined>(schedules: Schedules<D>): Schedules<D>;
+/** The module the repository root defines its jobs in. */
+export declare const SCHEDULES_MODULE = "schedules";
+/** A job's name in the build's function registry: `schedule.<name>` (a `noCase` function). */
+export declare const SCHEDULE_FUNCTION_PREFIX = "schedule.";
+export declare function scheduleFunctionName(name: string): string;
+/** When each job of a build runs, by job name; its code is `functions[scheduleFunctionName(name)]`. */
+export type ScheduleManifest = Record<string, {
+    cron: string;
+    timezone: string;
+}>;
+//# sourceMappingURL=schedules.d.ts.map

package/dist/core/functions/schedules.js

@@ -0,0 +1,20 @@
+/**
+ * Author-side helper for `schedules.ts`:
+ *
+ * ```ts
+ * export const schedules = defineSchedules({
+ *   nightlySync: { cron: '0 2 * * *', timezone: 'UTC', run: async (ctx, { schedule }) => { … } },
+ * });
+ * ```
+ */
+export function defineSchedules(schedules) {
+    return schedules;
+}
+/** The module the repository root defines its jobs in. */
+export const SCHEDULES_MODULE = 'schedules';
+/** A job's name in the build's function registry: `schedule.<name>` (a `noCase` function). */
+export const SCHEDULE_FUNCTION_PREFIX = 'schedule.';
+export function scheduleFunctionName(name) {
+    return `${SCHEDULE_FUNCTION_PREFIX}${name}`;
+}
+//# sourceMappingURL=schedules.js.map

package/dist/core/functions/types.d.ts

@@ -1,78 +1,34 @@
-import type { FieldPath } from '../slot/path.js';
-import type { CaseContext, SystemContext, Writes } from '../context/types.js';
-export type FuncOptions = {
-    args?: Record<string, unknown>;
-    description?: string;
-};
-/** First arg is CaseContext (or Slots when the sequence has no view). */
-export type ComputeFn<S = CaseContext, R = unknown> = (caseContext: S) => R | Promise<R>;
-export type FunctionCtx<Params extends object> = SystemContext & {
-    params: Params;
-};
-export type CustomFn<S = CaseContext, P extends object = object> = (caseContext: S, ctx: FunctionCtx<P>) => Promise<Writes | null>;
-/** Inbound webhook request payload. */
-export type WebHookFunctionParams = {
-    headers: Record<string, string | string[] | undefined>;
-    body: unknown;
-    rawBody?: string;
-};
-export type FunctionCall<Params extends object, Return> = (ctx: FunctionCtx<Params>) => Promise<Return>;
-export type WebHookFunction = FunctionCall<WebHookFunctionParams, void>;
-export type GetFirstMessageParams<S = CaseContext> = {
-    caseContext: S;
-};
-export type GetFirstMessageFunction<S = CaseContext> = FunctionCall<GetFirstMessageParams<S>, string>;
-/** Object-key → implementation type for platform-invoked entries. */
-export type SystemFuncMap = {
-    webhook: WebHookFunction;
-    getFirstMessage: GetFirstMessageFunction;
-};
-type FuncMeta = {
-    description?: string;
-    args?: Record<string, unknown>;
-};
-/** One entry in a plain `functions` map (`{ name: define*Func(...) }`). */
-export type DefinedFunc = (FuncMeta & {
-    kind: 'compute' | 'boolCompute';
-    /** Implementation retained for compile → registry `code`; stripped from JSON via toFunctionRegistry. */
-    main: ComputeFn;
-}) | (FuncMeta & {
-    kind: 'custom';
-    main: CustomFn;
-}) | (FuncMeta & {
-    kind: 'system';
-    main: FunctionCall<object, unknown>;
-});
+import type { SystemContext } from '../context/types.js';
+import type { Db } from '../page/define.js';
+import type { PageTablesDesc, TypedDb } from '../page/typed.js';
+/**
+ * `ctx` of every function and entry (38 §2.3): what it is called with besides its `args`. `ctx.api.db`
+ * reads and writes records like a page script and its actions (15 §10.15 task 4): any row of the
+ * company and environment, each write its own transaction. `D` (the company's `PageTables`, bound by
+ * `__gen`) types them.
+ */
+export type Ctx<D extends PageTablesDesc | undefined = undefined> = Omit<SystemContext, 'api' | 'meta'> & {
+    /** What runs, where (38 §2.3): the instance a function works on is in its `args`, not here. */
+    meta: Omit<SystemContext['meta'], 'instanceId'>;
+    api: Omit<SystemContext['api'], 'db'> & {
+        db: D extends PageTablesDesc ? TypedDb<D> : Db;
+    };
+};
+/**
+ * A function as the company writes it (38 §2.1): `(ctx, args)`, `args` one object (`{}` when it takes
+ * none). Every entry the platform calls (functions, event handlers, `resolve`, the webhook, a schedule's
+ * `run`, the Orchestrator) is one; the platform tells its entries apart by name.
+ */
+export type PlainFn = (ctx: any, args: any) => Promise<unknown>;
 /** Author map: key is the function name. */
-export type FuncMap = Record<string, DefinedFunc>;
-/** Map entry with name stamped from the key (for platform loaders). */
-export type FuncRegistration = DefinedFunc & {
-    name: string;
-};
-type RegistryCode = {
-    /**
-     * Standalone JS function expression (esbuild-normalized).
-     * Present on published builds; omitted on local serve overlay (`includeCode: false`).
-     */
+export type FuncMap = Record<string, PlainFn>;
+/**
+ * Compiled function registry entry (JSON-safe). Same shape for `functions` and `events`. `code` is the
+ * standalone JS function expression (esbuild-normalized): present on published builds, omitted on the
+ * local serve overlay (`includeCode: false`).
+ */
+export type FunctionRegistryEntry = {
     code?: string;
 };
-/** Compiled function registry entry shapes (JSON-safe). */
-export type FunctionRegistryEntry = (RegistryCode & {
-    kind: 'compute' | 'boolCompute';
-}) | (RegistryCode & {
-    kind: 'custom';
-    writes: FieldPath[];
-}) | (RegistryCode & {
-    kind: 'system';
-});
 export type FunctionRegistry = Record<string, FunctionRegistryEntry>;
-/** Compiled CaseContext projector (optional on SequenceBuild). */
-export type CaseContextViewRegistryEntry = {
-    kind: 'caseContextView';
-    /** Present on published builds; omitted on local serve overlay. */
-    code?: string;
-};
-/** Stamp `name` from object keys when the platform loads a functions map. */
-export declare function toFuncRegistrations(functions: FuncMap): FuncRegistration[];
-export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/core/functions/types.js

@@ -1,5 +1,2 @@
-/** Stamp `name` from object keys when the platform loads a functions map. */
-export function toFuncRegistrations(functions) {
-    return Object.entries(functions).map(([name, def]) => ({ ...def, name }));
-}
+export {};
 //# sourceMappingURL=types.js.map

package/dist/core/office-hours/index.d.ts

@@ -0,0 +1,39 @@
+export type Window = {
+    start: string;
+    end: string;
+};
+export type Weekday = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
+/** Company `office-hours.ts` config. */
+export type OfficeHours = {
+    /** IANA timezone name for the office (e.g. `'America/New_York'`). */
+    timezone: string;
+    /** Standard weekly open windows per weekday (`[]` means closed that weekday). */
+    week: Record<Weekday, Window[]>;
+    /** Recurring annual dates (`MM-DD`) whose `hours` replace `week` (`[]` means closed all day). */
+    holidays: {
+        date: string;
+        hours: Window[];
+    }[];
+    /** One-off calendar dates (`YYYY-MM-DD`) whose `hours` take precedence over both `holidays` and `week`. */
+    overrides: {
+        date: string;
+        hours: Window[];
+    }[];
+};
+/** The office hours now (`ctx.officeHours` of a page). `open` / `today` are filled by `resolveOfficeHours(now)`. */
+export type OfficeHoursSnapshot = OfficeHours & {
+    /** Whether the office is currently open at the resolved timestamp (`ctx.time.now`). */
+    open: boolean;
+    /** Effective open windows for today's date in `timezone` (after applying `overrides` / `holidays` / `week`). */
+    today: Window[];
+};
+export type ParseOfficeHoursResult = {
+    ok: true;
+    value: OfficeHours;
+} | {
+    ok: false;
+    issues: string[];
+};
+export declare function parseOfficeHours(value: unknown): ParseOfficeHoursResult;
+export declare function resolveOfficeHours(config: OfficeHours | null | undefined, now: number): OfficeHoursSnapshot | null;
+//# sourceMappingURL=index.d.ts.map