@akumzy/cron-api-sdk/dist/index.d.ts

TypeScript SDK for Cron API and Reminder services

import { AxiosInstance } from 'axios';

interface Job {
    id: number;
    name: string;
    schedule: string;
    method: string;
    url: string;
    headers: Record<string, string>;
    payload: string;
    active: boolean;
}
interface JobLog {
    job_id: number;
    executed_at: string;
    status: number;
    response: string;
    error: string;
}
interface Service {
    id: string;
    endpoint: string;
    name: string;
    description?: string;
    created_at: string;
    updated_at: string;
}
type ReminderType = 'one-off' | 'recurring';
type ReminderStatus = 'pending' | 'sent' | 'failed' | 'canceled';
interface Reminder {
    id: string;
    type: ReminderType;
    service_id: string;
    message: string;
    status: ReminderStatus;
    created_at: string;
    updated_at: string;
    scheduled_time?: string;
    time?: string;
    date?: number;
    month?: number;
    year?: number;
    timezones?: string[];
}
interface ReminderLog {
    id: string;
    reminder_id: string;
    executed_at: string;
    status: number;
    response: string;
    error: string;
    timezone: string;
}
interface ApiResponse<T = any> {
    data: T;
    status: number;
    statusText: string;
}
interface CreateJobRequest extends Omit<Job, 'id'> {
}
interface UpdateJobRequest extends Job {
}
interface CreateReminderRequest extends Omit<Reminder, 'id' | 'created_at' | 'updated_at' | 'status'> {
}
interface UpdateReminderRequest extends Reminder {
}
interface CreateServiceRequest extends Omit<Service, 'id' | 'created_at' | 'updated_at'> {
}
interface UpdateServiceRequest extends Service {
}
interface CronApiConfig {
    baseURL: string;
    timeout?: number;
    headers?: Record<string, string>;
    auth?: {
        username: string;
        password: string;
    };
}
interface TriggerJobResponse {
    message: string;
}
interface TriggerReminderResponse {
    message: string;
}

declare class BaseClient {
    protected client: AxiosInstance;
    constructor(config: CronApiConfig);
    protected _get<T>(url: string): Promise<T>;
    protected _post<T>(url: string, data?: any): Promise<T>;
    protected _put<T>(url: string, data?: any): Promise<T>;
    protected _delete<T>(url: string): Promise<T>;
    /**
     * Health check endpoint
     */
    ping(): Promise<{
        message: string;
    }>;
}

declare class JobsClient extends BaseClient {
    constructor(config: CronApiConfig);
    /**
     * Get all jobs
     */
    getAll(): Promise<Job[]>;
    /**
     * Get a job by ID
     */
    getById(id: number): Promise<Job>;
    /**
     * Create a new job
     */
    create(job: CreateJobRequest): Promise<Job>;
    /**
     * Update an existing job
     */
    update(job: UpdateJobRequest): Promise<Job>;
    /**
     * Delete a job
     */
    delete(id: number): Promise<void>;
    /**
     * Get logs for a specific job
     */
    getLogs(id: number): Promise<JobLog[]>;
    /**
     * Manually trigger a job
     */
    trigger(id: number): Promise<TriggerJobResponse>;
    /**
     * Get all logs across all jobs
     */
    getAllLogs(): Promise<JobLog[]>;
}

declare class RemindersClient extends BaseClient {
    constructor(config: CronApiConfig);
    /**
     * Get all reminders
     */
    getAll(): Promise<Reminder[]>;
    /**
     * Get a reminder by ID
     */
    getById(id: string): Promise<Reminder>;
    /**
     * Create a new reminder
     */
    create(reminder: CreateReminderRequest): Promise<Reminder>;
    /**
     * Update an existing reminder
     */
    update(reminder: UpdateReminderRequest): Promise<Reminder>;
    /**
     * Delete a reminder
     */
    delete(id: string): Promise<void>;
    /**
     * Get logs for a specific reminder
     */
    getLogs(id: string): Promise<ReminderLog[]>;
    /**
     * Manually trigger a reminder
     */
    trigger(id: string): Promise<TriggerReminderResponse>;
    /**
     * Get all reminder logs across all reminders
     */
    getAllLogs(): Promise<ReminderLog[]>;
}

declare class ServicesClient extends BaseClient {
    constructor(config: CronApiConfig);
    /**
     * Get all services
     */
    getAll(): Promise<Service[]>;
    /**
     * Get a service by ID
     */
    getById(id: string): Promise<Service>;
    /**
     * Create a new service
     */
    create(service: CreateServiceRequest): Promise<Service>;
    /**
     * Update an existing service
     */
    update(service: UpdateServiceRequest): Promise<Service>;
    /**
     * Delete a service
     */
    delete(id: string): Promise<void>;
}

declare class CronApiSDK {
    readonly jobs: JobsClient;
    readonly reminders: RemindersClient;
    readonly services: ServicesClient;
    constructor(config: CronApiConfig);
    /**
     * Test connection to the API
     */
    ping(): Promise<{
        message: string;
    }>;
    /**
     * Create SDK instance with default configuration
     */
    static create(baseURL: string, auth?: {
        username: string;
        password: string;
    }): CronApiSDK;
    /**
     * Create SDK instance for development
     */
    static createForDev(auth?: {
        username: string;
        password: string;
    }): CronApiSDK;
}

/**
 * Utility functions for working with cron expressions and scheduling
 */
declare class CronUtils {
    /**
     * Validate a cron expression
     * Basic validation for standard 5-field cron expressions
     */
    static validateCronExpression(expression: string): boolean;
    /**
     * Common cron expressions
     */
    static readonly commonExpressions: {
        everyMinute: string;
        every5Minutes: string;
        every15Minutes: string;
        every30Minutes: string;
        everyHour: string;
        everyDay: string;
        everyWeek: string;
        everyMonth: string;
        everyYear: string;
        weekdays: string;
        weekends: string;
    };
    /**
     * Parse cron expression into human-readable format
     */
    static parseCronExpression(expression: string): string;
    private static humanizeCommonExpression;
    private static getOrdinalSuffix;
    /**
     * Get next execution times for a cron expression
     * Note: This is a simplified implementation
     */
    static getNextExecutions(expression: string, count?: number): Date[];
    private static matchesCronExpression;
    /**
     * Create a cron expression from components
     */
    static createCronExpression(options: {
        minute?: number | string;
        hour?: number | string;
        day?: number | string;
        month?: number | string;
        dayOfWeek?: number | string;
    }): string;
}

export { ApiResponse, BaseClient, CreateJobRequest, CreateReminderRequest, CreateServiceRequest, CronApiConfig, CronApiSDK, CronUtils, Job, JobLog, JobsClient, Reminder, ReminderLog, ReminderStatus, ReminderType, RemindersClient, Service, ServicesClient, TriggerJobResponse, TriggerReminderResponse, UpdateJobRequest, UpdateReminderRequest, UpdateServiceRequest, CronApiSDK as default };