interface CronhostConfig {
  apiKey: string; // Your Cronhost API key (required)
  baseUrl?: string; // Custom base URL (optional, defaults to https://cronho.st)
}

interface Schedule {
  id: string; // Unique schedule identifier
  name: string; // Human-readable schedule name
  description?: string; // Optional description
  cronExpression: string; // Cron expression for scheduling
  timezone: string; // IANA timezone identifier - see /timezones
  endpoint: string; // Target HTTP endpoint
  httpMethod: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
  body?: string; // Request body (for POST/PUT/PATCH)
  headers?: string; // HTTP headers as JSON string
  isEnabled: boolean; // Whether schedule is active
  nextRunAtUtc: Date; // Next scheduled execution time
  lastRunAtUtc?: Date; // Last execution time (if any)
  createdAt: Date; // Schedule creation timestamp
  updatedAt: Date; // Last modification timestamp
  maxRetries: number; // Total attempts including the first (1-10)
  timeoutSeconds: number; // Request timeout in seconds (1-300)
  expectedStatusCodes?: string | null; // Codes counted as success; null = default (< 400)
}

interface Job {
  id: string; // Unique job identifier
  scheduleId: string; // Associated schedule ID
  status: "PENDING" | "RUNNING" | "SUCCESS" | "FAILED";
  scheduledRunAtUtc: Date; // Original scheduled run time
  attemptNumber: number; // Current retry attempt (1-based)
  httpMethod: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
  endpoint: string; // Target endpoint URL
  body?: string; // Request body (if applicable)
  headers?: string; // Request headers as JSON string
  statusCode?: number; // HTTP response status code
  response?: string; // HTTP response body
  startedAtUtc?: Date; // Execution start time
  completedAtUtc?: Date; // Execution completion time
  errorMessage?: string; // Error details (if failed)
  createdAt: Date; // Job creation timestamp
  updatedAt: Date; // Last update timestamp
}

interface CreateScheduleData {
  name: string; // Schedule name (required)
  description?: string; // Optional description
  cronExpression: string; // Cron expression (required)
  timezone: string; // IANA timezone (required) - see /timezones
  endpoint: string; // Target URL (required)
  httpMethod: "GET" | "POST" | "PUT" | "DELETE" | "PATCH"; // HTTP method (required)
  body?: string; // Request body
  headers?: Record<string, string>; // HTTP headers as key-value pairs
  maxRetries?: number; // Total attempts including the first, clamped to 1-10 (default 3)
  timeoutSeconds?: number; // Timeout in seconds, clamped to 1-300 (default 30)
  expectedStatusCodes?: string; // Codes counted as success (e.g. "200-299,410")
}

interface UpdateScheduleData {
  name?: string; // Update schedule name
  description?: string; // Update description
  cronExpression?: string; // Update cron expression
  timezone?: string; // Update timezone - see /timezones
  endpoint?: string; // Update endpoint URL
  httpMethod?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH"; // Update HTTP method
  body?: string; // Update request body
  headers?: Record<string, string>; // Update HTTP headers
  maxRetries?: number; // Total attempts including the first, clamped to 1-10
  timeoutSeconds?: number; // Timeout in seconds, clamped to 1-300
  expectedStatusCodes?: string; // Codes counted as success; "" clears to default
}

interface GetJobsParams {
  scheduleId: string; // Required: the schedule whose jobs to list
  status?: "PENDING" | "RUNNING" | "SUCCESS" | "FAILED"; // Filter by status
  page?: number; // Page number, 1-based (default: 1)
  pageSize?: number; // Items per page (default: 20, max: 100)
}

interface JobsPage {
  jobs: Job[]; // Jobs on the current page
  page: number; // Current page number (1-based)
  pageSize: number; // Items per page
  totalPages: number; // Total number of pages
  total: number; // Total jobs matching the query
}

interface ApiResponse<T> {
  data: T; // Response payload
  success: boolean; // Always true for successful responses
  message?: string; // Optional success message
}

interface ApiError {
  error: {
    message: string; // Human-readable error message
    code: string; // Error code for programmatic handling
    details?: any; // Additional error details (e.g., validation errors)
  };
}

type NotificationChannelType = "email" | "slack" | "discord" | "telegram";

interface NotificationChannel {
  id: string;
  type: NotificationChannelType;
  verified: boolean; // Only verified channels can be attached to a schedule
  label: string;
  createdAt: Date;
  updatedAt: Date;
}

interface EmailChannelConfig {
  to: string;
}
interface WebhookChannelConfig {
  webhookUrl: string;
} // slack, discord
interface TelegramChannelConfig {
  botToken: string;
  chatId?: string; // discovered during verification if omitted
}

type CreateNotificationChannelData =
  | { type: "email"; label: string; config: EmailChannelConfig }
  | { type: "slack"; label: string; config: WebhookChannelConfig }
  | { type: "discord"; label: string; config: WebhookChannelConfig }
  | { type: "telegram"; label: string; config: TelegramChannelConfig };

interface UpdateNotificationChannelData {
  label?: string;
  config?: Record<string, unknown>;
}

type NotifyOn = "none" | "success" | "failure" | "both";

interface PreferenceChannelRef {
  channelId: string;
  type: NotificationChannelType;
  label: string;
  verified: boolean;
}

interface ScheduleNotificationPreference {
  scheduleId: string;
  notifyOn: NotifyOn;
  channels: PreferenceChannelRef[];
  warning?: string | null; // non-blocking advisory
}

interface SetScheduleNotificationData {
  notifyOn: NotifyOn;
  channelIds?: string[]; // required when notifyOn is not "none"
}

type JobStatus = "PENDING" | "RUNNING" | "SUCCESS" | "FAILED";

type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";

import { Cronhost, CreateScheduleData, Schedule } from "cronhost";

const cronhost = new Cronhost({
  apiKey: "your-api-key",
});

const scheduleData: CreateScheduleData = {
  name: "API Health Check",
  description: "Check API status every hour",
  cronExpression: "0 * * * *",
  timezone: "UTC",
  endpoint: "https://api.example.com/health",
  httpMethod: "GET",
  headers: {
    "User-Agent": "Cronhost-Monitor",
    Accept: "application/json",
  },
  maxRetries: 3,
  timeoutSeconds: 30,
};

const schedule: Schedule = await cronhost.createSchedule(scheduleData);

import { Job, GetJobsParams } from "cronhost";

const jobParams: GetJobsParams = {
  scheduleId: "schedule-123",
  status: "FAILED",
  page: 1,
  pageSize: 20,
};

const { jobs } = await cronhost.getJobs(jobParams);

jobs.forEach((job: Job) => {
  console.log(`Job ${job.id} failed: ${job.errorMessage}`);
});

function isSuccessfulJob(
  job: Job
): job is Job & { statusCode: number; response: string } {
  return (
    job.status === "SUCCESS" &&
    job.statusCode !== undefined &&
    job.response !== undefined
  );
}

function isFailedJob(job: Job): job is Job & { errorMessage: string } {
  return job.status === "FAILED" && job.errorMessage !== undefined;
}

// Usage
const job = await cronhost.getJob("job-id");

if (isSuccessfulJob(job)) {
  console.log(`Success! Status: ${job.statusCode}, Response: ${job.response}`);
} else if (isFailedJob(job)) {
  console.log(`Failed: ${job.errorMessage}`);
}