Node.js SDK

Installation

pnpm

pnpm add @chronos.sh/sdk

npm

npm install @chronos.sh/sdk

yarn

yarn add @chronos.sh/sdk

• Requires Node.js 20+
• The resource clients (schedules, jobs, executions) need version 0.2.0 or later
• jobs.wait and account need version 0.3.0 or later
• Dual module: ESM (import) and CJS (require) both supported
• Zero runtime dependencies

Chronos

The top-level client. Webhook is the only other class you construct.

import { Chronos } from '@chronos.sh/sdk';

const chronos = new Chronos({
  apiKey: process.env.CHRONOS_API_KEY!,
});

Constructor

new Chronos(options: ChronosOptions)

Throws ChronosConfigError if any option fails validation.

Properties

All read-only.

Property	Type	Description
worker	Worker	The long-poll worker for pull delivery.
schedules	Schedules	Create, change and inspect recurring schedules.
jobs	Jobs	Create one-off jobs and inspect or act on any job.
executions	Executions	Inspect delivery attempts.
account	Account	Read the workspace the API key belongs to.

Worker

Accessed via chronos.worker. Not directly importable.

.handle<TPayload>(name, handler)

handle<TPayload = unknown>(name: string, handler: ChronosHandler<TPayload>): this

Register a handler for a named job type. Returns this for chaining.

Parameter	Type	Description
name	string	Job type name. Trimmed internally. Must be 1–255 characters.
handler	ChronosHandler<TPayload>	Async or sync function that processes the job.

Throws ChronosError:

• 'Handler name is required': empty or whitespace-only name
• 'Handler name must be 255 characters or fewer'
• 'Handler "{name}" is already registered': duplicate name
• 'Handler "{name}" must be a function': non-function passed

.start()

start(): Promise<void>

Begin long-polling for jobs. The returned promise resolves when stop() is called and all in-flight work completes, or rejects with ChronosAuthenticationError if any request gets a 401. A 401 that lands after stop() was called is logged and the promise resolves.

Throws ChronosError (synchronously):

• 'Chronos worker is already started'
• 'Register at least one handler before starting Chronos'

.stop()

stop(): Promise<void>

Request graceful shutdown.

1. Aborts the current long-poll immediately
2. Waits for any in-flight handler to finish (or hit its timeout) and report its result
3. Resolves when complete

Safe to call at any time and never rejects: a credential rejection surfaces on start() as ChronosAuthenticationError instead, or is only logged when it lands after this call. Bounded by the handler timeout plus timeoutMs per report attempt; see Graceful Shutdown for the arithmetic.

Resources

The resource clients chronos.schedules, chronos.jobs, chronos.executions and chronos.account call the REST API with your API key. Request and response fields use the API’s snake_case names, and timestamps are ISO 8601 strings. The REST reference documents every field.

Every method takes an optional last argument, ChronosRequestOptions. An API rejection throws ChronosApiError. An empty id rejects with ChronosError before any request is sent; a malformed id gets a 422 validation_error from the API.

const schedule = await chronos.schedules.create({
  name: 'Nightly report',
  handler: 'send-report',
  cron: '0 2 * * *',
  timezone: 'Europe/London',
});

await chronos.schedules.pause(schedule.id);

Schedules

Method	Request	Returns
create(params)	POST /v1/schedules	ChronosSchedule
list(params?)	GET /v1/schedules	ChronosPage<ChronosSchedule>
iterate(params?)	GET /v1/schedules, every page	AsyncIterable<ChronosSchedule>
get(id)	GET /v1/schedules/{id}	ChronosSchedule
update(id, params)	PATCH /v1/schedules/{id}	ChronosSchedule
delete(id)	DELETE /v1/schedules/{id}	void
pause(id)	POST /v1/schedules/{id}/pause	ChronosSchedule
resume(id)	POST /v1/schedules/{id}/resume	ChronosSchedule
trigger(id)	POST /v1/schedules/{id}/trigger	ChronosJob
archive(id)	POST /v1/schedules/{id}/archive	ChronosSchedule

Param types: ChronosScheduleCreateParams, ChronosScheduleUpdateParams, ChronosScheduleListParams. In update, null clears a field.

Jobs

Method	Request	Returns
create(params)	POST /v1/jobs	ChronosJob
list(params?)	GET /v1/jobs	ChronosPage<ChronosJob>
iterate(params?)	GET /v1/jobs, every page	AsyncIterable<ChronosJob>
get(id)	GET /v1/jobs/{id}	ChronosJob
cancel(id)	POST /v1/jobs/{id}/cancel	ChronosJob
skip(id)	POST /v1/jobs/{id}/skip	ChronosJob
retry(id)	POST /v1/jobs/{id}/retry	ChronosJob
wait(id)	GET /v1/jobs/{id}, polled	ChronosJob

Param types: ChronosJobCreateParams, ChronosJobListParams. wait takes ChronosJobWaitOptions, which adds pollIntervalMs and maxWaitMs to ChronosRequestOptions.

jobs.wait waits a second between checks until the job is completed, failed, cancelled or skipped, and returns it. A failed job is returned, not thrown, so check its status. After 60 seconds it throws ChronosWaitTimeoutError. It rethrows any other error from a check, such as ChronosApiError for an unknown id. To change either default, set pollIntervalMs or maxWaitMs. Aborting signal stops the whole wait and rejects with the signal’s reason. timeoutMs and maxRequestRetries apply to each check. A pull job finishes only while a worker with its handler is running.

const created = await chronos.jobs.create({ name: 'Welcome email', handler: 'send-email' });
const job = await chronos.jobs.wait(created.id, { maxWaitMs: 120_000 });
if (job.status === 'failed') {
  console.error(job.last_error);
}

jobs.create is never retried after a 5xx or a network error, because the job may already exist. To retry it yourself, pass an idempotency_key and treat idempotency_key_conflict as success:

import { ChronosApiError } from '@chronos.sh/sdk';

async function scheduleCharge(invoiceId: string) {
  try {
    await chronos.jobs.create({
      name: `Charge ${invoiceId}`,
      handler: 'charge-invoice',
      idempotency_key: `charge-${invoiceId}`,
    });
  } catch (err) {
    if (err instanceof ChronosApiError && err.code === 'idempotency_key_conflict') return;
    throw err;
  }
}

Executions

Method	Request	Returns
list(params?)	GET /v1/executions	ChronosPage<ChronosExecution>
iterate(params?)	GET /v1/executions, every page	AsyncIterable<ChronosExecution>
get(id)	GET /v1/executions/{id}	ChronosExecution

Param type: ChronosExecutionListParams. Pass schedule_id: null to match executions of jobs without a schedule.

Account

Method	Request	Returns
get()	GET /v1/account	ChronosAccount

ChronosAccount is { id, name, timezone, created_at } for the workspace the API key belongs to. To check a key at startup, call chronos.account.get(). An unknown or revoked key throws ChronosAuthenticationError. A missing key throws ChronosConfigError at new Chronos().

Lists and pages

list() returns one page, newest first:

const { data, paging } = await chronos.jobs.list({ status: 'failed', page: 2, size: 50 });
// paging: { page: 2, pages: 4, size: 50, total: 173 }

iterate() walks every page, fetching 100 items per request unless you set size. Each item is yielded at most once. Pages are offsets, so a row deleted or changed out of your filter during the walk shifts later rows onto earlier pages, and iterate() can miss some of them.

That includes changes you make yourself. Retrying a failed job moves it out of status: 'failed', so collect the ids before acting on them:

const failed = [];
for await (const job of chronos.jobs.iterate({ status: 'failed' })) {
  failed.push(job.id);
}
for (const id of failed) {
  await chronos.jobs.retry(id);
}

Breaking out of the loop stops further requests.

Retries

Resource methods retry a request only when repeating it is safe:

Failure	GET	POST, PATCH, DELETE
429	Retried	Retried
5xx	Retried	Thrown
Network error or timeout	Retried	Thrown
Other 4xx	Thrown	Thrown

A 429 is safe to retry for any method, because the API rejects it before doing any work.

• Waits back off from 0.5s, doubling up to 8s, each shortened by up to 25% of random jitter. A Retry-After header sets the wait instead. Above 60 seconds, the SDK throws the error without waiting.
• maxRequestRetries (default 2) sets the number of retries, per client or per call.
• timeoutMs applies to each attempt, not to the whole call.
• The worker ignores maxRequestRetries and keeps its own retry loops.

Types

ChronosOptions

type ChronosOptions = {
  apiKey: string;
  baseUrl?: string;
  fetch?: FetchLike;
  logger?: ChronosLogger;
  pollWaitTimeSeconds?: number;
  timeoutMs?: number;
  maxRequestRetries?: number;
  retryDelayMs?: number;
  workerId?: string;
};

Option	Type	Default	Validation
apiKey	string	— (required)	Trimmed. Throws ChronosConfigError if empty.
baseUrl	string	'https://api.chronos.sh'	Trimmed, trailing slashes stripped. Throws if empty after trim.
fetch	FetchLike	globalThis.fetch	None.
logger	ChronosLogger	Console-backed logger	None.
pollWaitTimeSeconds	number	20	Integer, 0–20 inclusive. Throws ChronosConfigError.
timeoutMs	number	30000	Positive integer up to 2147483647. Throws ChronosConfigError.
maxRequestRetries	number	2	Non-negative integer. Throws ChronosConfigError.
retryDelayMs	number	1000	Finite, non-negative. Throws ChronosConfigError.
workerId	string	Auto-generated	Trimmed. 1–255 characters after trim. Throws ChronosConfigError.

timeoutMs bounds each HTTP attempt the SDK makes; an attempt that exceeds it fails with ChronosTimeoutError. Long-poll claim requests get pollWaitTimeSeconds × 1000 of extra headroom so the intentional wait never counts against the bound. workerId is the identity reported to the API on every claim; set it to a stable value when you want the same worker identity across restarts. maxRequestRetries applies to resource methods, as described in Retries.

ChronosContext<TPayload>

type ChronosContext<TPayload = unknown> = {
  jobId: string;
  executionId: string;
  handler: string;
  payload: TPayload;
  scheduledFor: Date;
  attempt: number;
  timeout: number;
  signal: AbortSignal;
  schedule: ChronosScheduleReference | null;
};

Field	Type	Description
jobId	string	Stable job identifier. Same across retries. Use for idempotency keys in downstream calls.
executionId	string	Unique to this execution attempt. Use for per-attempt logs, metrics, and correlation.
handler	string	Handler name that matched this job.
payload	TPayload	Job payload. Typed via the generic on .handle<TPayload>().
scheduledFor	Date	When the job was originally scheduled. Parsed from ISO string.
attempt	number	Attempt number. 1 on first try, increments on retries.
timeout	number	Timeout for the handler in seconds. The SDK races the handler against this duration and aborts ctx.signal when it elapses.
signal	AbortSignal	Fires when timeout elapses. Pass to fetch, AbortSignal.any(), etc.
schedule	ChronosScheduleReference | null	Parent schedule, or null for one-off jobs.

ChronosScheduleReference

type ChronosScheduleReference = {
  id: string;
  name: string;
};

The schedule that produced a claimed job. Named ChronosSchedule before 0.2.0; ChronosSchedule is now the full schedule resource.

ChronosRequestOptions

type ChronosRequestOptions = {
  signal?: AbortSignal;
  timeoutMs?: number;
  maxRequestRetries?: number;
};

The optional last argument of every resource method. signal aborts the request and any wait between retries, rejecting with the signal’s reason. timeoutMs and maxRequestRetries override the client options for that call; invalid values reject with ChronosConfigError.

ChronosPage<T>

type ChronosPage<T> = {
  data: T[];
  paging: ChronosPaging; // { page, pages, size, total }
};

What list() returns. pages is 0 for an empty list. list() accepts page (default 1) and size (1 to 100, default 20).

Resource types

ChronosSchedule, ChronosJob and ChronosExecution match the objects the REST API returns, field for field. Their status unions are ChronosScheduleStatus, ChronosJobStatus and ChronosExecutionStatus. Shared shapes:

Type	Shape
ChronosInterval	{ value: number; unit: ChronosIntervalUnit }, used by schedule interval and job delay
ChronosIntervalUnit	'second' | 'minute' | 'hour' | 'day' | 'week'
ChronosDelivery	{ type: 'pull' } | { type: 'push'; http: ChronosHttpDeliveryConfig }
ChronosHttpDeliveryConfig	{ url: string; method: ChronosHttpMethod; headers?: Record<string, string> }

RateLimitInfo

type RateLimitInfo = {
  limit: number;
  remaining: number;
  reset: number;
};

Field	Type	Description
limit	number	Maximum requests allowed per window.
remaining	number	Requests remaining in the current window.
reset	number	Seconds until the current window resets.

Attached to ChronosApiError.rateLimit on non-429 error responses. All three X-RateLimit-* headers must be present; if any is missing, rateLimit is undefined.

ChronosHandler<TPayload>

type ChronosHandler<TPayload = unknown> = (
  ctx: ChronosContext<TPayload>,
) => ChronosHandlerResult | Promise<ChronosHandlerResult>;

Can be sync or async.

ChronosHandlerResult

type ChronosHandlerResult = Record<string, unknown> | void;

Return value	Effect
Plain object	Recorded as execution result. Must be JSON-serializable.
undefined / void	Execution marked completed, no result data.

Rejected at runtime (throws ChronosError):

• Arrays
• Class instances (non-plain-object prototypes)
• Non-JSON-serializable values

ChronosLogger

type ChronosLogger = {
  debug(message: string, meta?: Record<string, unknown>): void;
  info(message: string, meta?: Record<string, unknown>): void;
  warn(message: string, meta?: Record<string, unknown>): void;
  error(message: string, meta?: Record<string, unknown>): void;
};

Signature is (message, meta?): message first, metadata second.

Adapting pino (which uses obj, message order):

import pino from 'pino';

const log = pino();

const chronos = new Chronos({
  apiKey: process.env.CHRONOS_API_KEY!,
  logger: {
    debug: (msg, meta) => log.debug(meta ?? {}, msg),
    info: (msg, meta) => log.info(meta ?? {}, msg),
    warn: (msg, meta) => log.warn(meta ?? {}, msg),
    error: (msg, meta) => log.error(meta ?? {}, msg),
  },
});

FetchLike

type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;

Compatible with globalThis.fetch. Use cases: inject tracing headers, test mocking. Implementations must forward init.signal to the underlying transport; dropping it disables the SDK’s transport timeout and graceful abort.

Webhook

Verifies signatures on push deliveries. Standalone: does not require a Chronos client or API key.

import { Webhook } from '@chronos.sh/sdk';

const wh = new Webhook(process.env.CHRONOS_SIGNING_SECRET!);
const payload = await wh.verify(rawBody, req.headers);

Constructor

new Webhook(secret: string | string[], options?: WebhookOptions)

Parameter	Type	Description
secret	string | string[]	Signing secret or array of secrets for key rotation. Blank/whitespace strings are filtered out.
options	WebhookOptions	Optional configuration.

Throws ChronosWebhookVerificationError if no valid (non-empty) secret is provided, or if toleranceSeconds is invalid.

.verify(body, headers)

verify(body: string, headers: Record<string, string | undefined> | Headers): Promise<unknown>

Verifies the signature and returns the parsed JSON body on success. Throws ChronosWebhookVerificationError on any failure.

Parameter	Type	Description
body	string	Raw request body. Must be the exact bytes received, not re-serialized.
headers	Record<string, string | undefined> | Headers	Request headers. Keys are matched case-insensitively. Accepts plain objects or the Web standard Headers class.

The method is async because it uses the Web Crypto API (crypto.subtle). Works in Node.js 18+, Bun, Deno, and edge runtimes.

Crypto keys are lazily imported on the first verify() call and cached for subsequent calls.

WebhookOptions

type WebhookOptions = {
  toleranceSeconds?: number;
};

Option	Type	Default	Description
toleranceSeconds	number	300	Timestamp tolerance in seconds. Rejects requests with timestamps more than this many seconds from now (in either direction). Set to 0 to disable replay protection entirely. Must be finite and non-negative.

DEFAULT_TIMESTAMP_TOLERANCE_SECONDS

const DEFAULT_TIMESTAMP_TOLERANCE_SECONDS = 300;

The default tolerance applied when toleranceSeconds is not specified.

Error hierarchy

Error
└── ChronosError
    ├── ChronosConfigError
    ├── ChronosApiError
    │   ├── ChronosAuthenticationError
    │   └── ChronosRateLimitError
    ├── ChronosNetworkError
    │   └── ChronosTimeoutError
    ├── ChronosWaitTimeoutError
    ├── ChronosHandlerError
    └── ChronosWebhookVerificationError

ChronosError

class ChronosError extends Error {
  readonly cause?: unknown;
  constructor(message: string, options?: { cause?: unknown });
}

Base class for all SDK errors. Catch this to handle any SDK error generically.

Thrown for operational issues: duplicate handler names, invalid return values, calling start() twice, an empty id passed to a resource method, or a list response without paging.

ChronosConfigError

class ChronosConfigError extends ChronosError {
  constructor(message: string);
}

Invalid options. Thrown by new Chronos(). A resource call rejects with it for an invalid timeoutMs or maxRequestRetries, and jobs.wait also rejects with it for an invalid pollIntervalMs or maxWaitMs.

Messages:

• 'Chronos apiKey is required'
• 'Chronos baseUrl is required'
• 'maxRequestRetries must be a non-negative integer'
• 'maxWaitMs must be a positive integer no greater than 2147483647'
• 'pollIntervalMs must be a positive integer no greater than 2147483647'
• 'pollWaitTimeSeconds must be an integer between 0 and 20'
• 'retryDelayMs must be a non-negative number'
• 'timeoutMs must be a positive integer no greater than 2147483647'
• 'workerId must be 1-255 characters'

ChronosApiError

class ChronosApiError extends ChronosError {
  readonly status: number;
  readonly code?: ChronosErrorCode;
  readonly fieldErrors: ChronosFieldError[];
  readonly body?: unknown;
  readonly requestId?: string;
  readonly retryAfterSeconds?: number;
  readonly rateLimit?: RateLimitInfo;
  constructor(message: string, options: ChronosApiErrorOptions);
}

Property	Type	Description
status	number	HTTP status code. Can be 200 if the API returned { success: false }.
code	ChronosErrorCode | undefined	Application error code, such as 'idempotency_key_conflict'. Typed for autocomplete and open to any string. See Error Codes.
fieldErrors	ChronosFieldError[]	Invalid fields of a rejected request, such as a 422 validation_error. Each is { message, field?, value? }. Empty when the API sent none.
body	unknown	Full parsed response body.
requestId	string | undefined	Value of the X-Request-Id response header.
retryAfterSeconds	number | undefined	Seconds to wait before retrying. Parsed from the Retry-After header on 429 and 5xx responses. Integer seconds only; undefined for HTTP-date values.
rateLimit	RateLimitInfo | undefined	Rate-limit budget from X-RateLimit-* headers. Present on non-429 error responses when all three headers exist.

Thrown when the API responds with a non-2xx status or a 2xx response with { success: false }. For 401 the SDK throws the ChronosAuthenticationError subclass and for 429 the ChronosRateLimitError subclass.

import { ChronosApiError } from '@chronos.sh/sdk';

try {
  await chronos.schedules.create({ name: 'Report', handler: 'report', cron: 'every day' });
} catch (err) {
  if (!(err instanceof ChronosApiError && err.code === 'validation_error')) throw err;
  for (const { field, message } of err.fieldErrors) {
    console.error(`${field}: ${message}`); // cron: cron must be a valid cron expression
  }
}

field is a dotted path such as delivery.http.url. A rule across several fields names the fields it checks, comma-separated: sending both cron and interval gives cron, interval on create and interval on update. A rule tied to no field, such as an empty update, gives null.

ChronosAuthenticationError

class ChronosAuthenticationError extends ChronosApiError {
  constructor(message: string, options: ChronosApiErrorOptions);
}

Thrown on any HTTP 401: the API key is missing, malformed, unknown, or revoked, or a proxy in front of the API rejected the request. Subclass of ChronosApiError. The worker stops on this error and start() rejects with it, unless stop() was already called, in which case the worker only logs it. When the 401 arrives on a result report, the log line carries the execution id and that result is not recorded.

import { ChronosAuthenticationError } from '@chronos.sh/sdk';

try {
  await chronos.worker.start();
} catch (err) {
  if (err instanceof ChronosAuthenticationError) {
    console.error('Rotate CHRONOS_API_KEY', { requestId: err.requestId });
    process.exit(1);
  }
  throw err;
}

ChronosRateLimitError

class ChronosRateLimitError extends ChronosApiError {
  constructor(message: string, options: ChronosApiErrorOptions);
}

Thrown on 429 Too Many Requests. Subclass of ChronosApiError, so existing instanceof ChronosApiError catches still work.

retryAfterSeconds is set when the response includes a Retry-After header; otherwise undefined. rateLimit is always undefined on 429.

import { ChronosRateLimitError } from '@chronos.sh/sdk';

function handleSdkError(err: unknown) {
  if (err instanceof ChronosRateLimitError && err.retryAfterSeconds) {
    console.warn(`Rate limited. Retry after ${err.retryAfterSeconds}s`);
  }
}

The worker handles 429s automatically and never rejects start() with this error. Resource methods retry a 429 up to maxRequestRetries times before throwing it. See Retries & Error Handling for details.

ChronosNetworkError

class ChronosNetworkError extends ChronosError {
  readonly cause: unknown;
  constructor(message: string, options: { cause: unknown });
}

Thrown when the request fails at the transport layer: DNS resolution failure, TCP connection refused, TLS errors, or a connection dropped mid-response.

cause contains the original error from fetch.

Not thrown for abort signals. If stop() aborts a poll, the raw abort error propagates (not wrapped in ChronosNetworkError). The SDK’s own transport timeout throws the ChronosTimeoutError subclass.

ChronosTimeoutError

class ChronosTimeoutError extends ChronosNetworkError {
  constructor(message: string, options: { cause: unknown });
}

Thrown when a request exceeds timeoutMs before the response completes, including a stall during the body read. Subclass of ChronosNetworkError, so generic transport-failure handling still catches it. cause is the underlying abort rejection (a TimeoutError DOMException on Node).

Message: 'Chronos API request timed out after {timeoutMs}ms', where the value is the effective timeout for that request. Long-poll claims report timeoutMs + pollWaitTimeSeconds × 1000 (50000ms at the defaults).

The worker treats it like any other transport failure: the poll loop waits retryDelayMs and resumes, and result reports get up to 3 attempts.

ChronosWaitTimeoutError

class ChronosWaitTimeoutError extends ChronosError {
  readonly job: ChronosJob | null;
  constructor(message: string, options: { job: ChronosJob | null });
}

Thrown by jobs.wait when the job has not finished after maxWaitMs. job is the last state seen, or null if no check finished in time. It is not a ChronosTimeoutError, which means a single request exceeded timeoutMs.

Message: 'Timed out after {maxWaitMs}ms waiting for job {id} (last status {status})', without the status part when job is null.

import { ChronosWaitTimeoutError } from '@chronos.sh/sdk';

try {
  const job = await chronos.jobs.wait(jobId);
} catch (err) {
  if (err instanceof ChronosWaitTimeoutError) {
    console.warn('Job still running', err.job?.status);
  }
}

ChronosHandlerError

class ChronosHandlerError extends ChronosError {
  readonly cause: unknown;
  constructor(message: string, options: { cause: unknown });
}

Wraps any exception thrown inside your handler. The message is copied from the original error (or stringified). If empty, defaults to 'Chronos handler failed'.

This error is never rethrown to your code. It’s logged internally and the failure is reported to the API. The error message (truncated to 4KB) is sent as the execution failure reason.

ChronosWebhookVerificationError

class ChronosWebhookVerificationError extends ChronosError {
  constructor(message: string);
}

Thrown by Webhook when any verification step fails: missing headers, invalid timestamp, bad signature format, wrong secret, or non-JSON body. Also thrown by the Webhook constructor if no valid secret is provided.

The message indicates the specific failure. See Signature Verification for the full list of messages.

import { Webhook, ChronosWebhookVerificationError } from '@chronos.sh/sdk';

const wh = new Webhook(process.env.CHRONOS_SIGNING_SECRET!);

try {
  const payload = await wh.verify(rawBody, headers);
} catch (err) {
  if (err instanceof ChronosWebhookVerificationError) {
    console.error('Verification failed:', err.message);
  }
}

Exports

Every named export from @chronos.sh/sdk:

Export	Kind	Description
Chronos	Class	Top-level client.
ChronosError	Class	Base error class for all SDK errors.
ChronosConfigError	Class	Invalid client options, an invalid per-call timeoutMs or maxRequestRetries, or an invalid jobs.wait option.
ChronosApiError	Class	API responded with an error.
ChronosAuthenticationError	Class	API responded with 401. Subclass of ChronosApiError.
ChronosRateLimitError	Class	API responded with 429. Subclass of ChronosApiError.
ChronosApiErrorOptions	Type	Options for constructing ChronosApiError.
ChronosErrorCode	Type	Known API error codes.
ChronosFieldError	Type	One invalid field on ChronosApiError.fieldErrors.
RateLimitInfo	Type	Rate-limit budget (limit, remaining, reset).
ChronosNetworkError	Class	Network/transport failure.
ChronosTimeoutError	Class	Request exceeded timeoutMs. Subclass of ChronosNetworkError.
ChronosWaitTimeoutError	Class	jobs.wait reached maxWaitMs.
ChronosHandlerError	Class	Handler threw an exception.
ChronosWebhookVerificationError	Class	Webhook signature verification failed.
Webhook	Class	Webhook signature verifier for push deliveries.
ChronosContext	Type	Context object passed to handlers.
ChronosHandler	Type	Handler function signature.
ChronosHandlerResult	Type	Valid handler return types.
ChronosLogger	Type	Logger interface.
ChronosOptions	Type	Constructor options.
ChronosScheduleReference	Type	Schedule reference on context.
ChronosRequestOptions	Type	Per-call options for resource methods.
ChronosPage, ChronosPaging, ChronosListParams	Type	List results and paging parameters.
ChronosSchedule, ChronosScheduleStatus, ChronosScheduleCreateParams, ChronosScheduleUpdateParams, ChronosScheduleListParams	Type	Schedule resource and params.
ChronosJob, ChronosJobStatus, ChronosJobOrigin, ChronosJobCreateParams, ChronosJobListParams, ChronosJobWaitOptions	Type	Job resource, params and wait options.
ChronosExecution, ChronosExecutionStatus, ChronosExecutionTrigger, ChronosExecutionListParams	Type	Execution resource and params.
ChronosAccount	Type	The workspace an API key belongs to.
ChronosDelivery, ChronosHttpDeliveryConfig, ChronosHttpMethod, ChronosInterval, ChronosIntervalUnit	Type	Shapes shared by schedules and jobs.
FetchLike	Type	Custom fetch signature.
WebhookOptions	Type	Options for Webhook constructor.
DEFAULT_BASE_URL	Constant	'https://api.chronos.sh'
DEFAULT_POLL_WAIT_TIME_SECONDS	Constant	20
DEFAULT_TIMEOUT_MS	Constant	30000
DEFAULT_MAX_REQUEST_RETRIES	Constant	2
SDK_VERSION	Constant	Package version string, reported on every claim and sent as user-agent: chronos-node/<version>.
DEFAULT_TIMESTAMP_TOLERANCE_SECONDS	Constant	300