@rustrak/client 0.1.2

package/dist/index.d.ts

@@ -0,0 +1,433 @@
+import { z, ZodSchema, ZodError } from 'zod';
+import { KyInstance } from 'ky';
+
+interface ClientConfig {
+    baseUrl: string;
+    token?: string;
+    timeout?: number;
+    maxRetries?: number;
+    headers?: Record<string, string>;
+}
+
+declare const channelTypeSchema: z.ZodEnum<{
+    webhook: "webhook";
+    email: "email";
+    slack: "slack";
+}>;
+declare const alertTypeSchema: z.ZodEnum<{
+    new_issue: "new_issue";
+    regression: "regression";
+    unmute: "unmute";
+}>;
+declare const alertStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    sent: "sent";
+    failed: "failed";
+    skipped: "skipped";
+}>;
+declare const notificationChannelSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    channel_type: z.ZodEnum<{
+        webhook: "webhook";
+        email: "email";
+        slack: "slack";
+    }>;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    is_enabled: z.ZodBoolean;
+    failure_count: z.ZodNumber;
+    last_failure_at: z.ZodNullable<z.ZodString>;
+    last_failure_message: z.ZodNullable<z.ZodString>;
+    last_success_at: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+declare const createNotificationChannelSchema: z.ZodObject<{
+    name: z.ZodString;
+    channel_type: z.ZodEnum<{
+        webhook: "webhook";
+        email: "email";
+        slack: "slack";
+    }>;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    is_enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const updateNotificationChannelSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    is_enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const alertRuleSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    project_id: z.ZodNumber;
+    name: z.ZodString;
+    alert_type: z.ZodEnum<{
+        new_issue: "new_issue";
+        regression: "regression";
+        unmute: "unmute";
+    }>;
+    is_enabled: z.ZodBoolean;
+    conditions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    cooldown_minutes: z.ZodNumber;
+    last_triggered_at: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    channel_ids: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+declare const createAlertRuleSchema: z.ZodObject<{
+    name: z.ZodString;
+    alert_type: z.ZodEnum<{
+        new_issue: "new_issue";
+        regression: "regression";
+        unmute: "unmute";
+    }>;
+    channel_ids: z.ZodArray<z.ZodNumber>;
+    is_enabled: z.ZodOptional<z.ZodBoolean>;
+    conditions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    cooldown_minutes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const updateAlertRuleSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    is_enabled: z.ZodOptional<z.ZodBoolean>;
+    conditions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    cooldown_minutes: z.ZodOptional<z.ZodNumber>;
+    channel_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+declare const alertHistorySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    alert_rule_id: z.ZodNullable<z.ZodNumber>;
+    channel_id: z.ZodNullable<z.ZodNumber>;
+    issue_id: z.ZodNullable<z.ZodString>;
+    project_id: z.ZodNullable<z.ZodNumber>;
+    alert_type: z.ZodString;
+    channel_type: z.ZodString;
+    channel_name: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        sent: "sent";
+        failed: "failed";
+        skipped: "skipped";
+    }>;
+    attempt_count: z.ZodNumber;
+    next_retry_at: z.ZodNullable<z.ZodString>;
+    error_message: z.ZodNullable<z.ZodString>;
+    http_status_code: z.ZodNullable<z.ZodNumber>;
+    idempotency_key: z.ZodString;
+    created_at: z.ZodString;
+    sent_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const testChannelResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+}, z.core.$strip>;
+
+type ChannelType = z.infer<typeof channelTypeSchema>;
+type AlertType = z.infer<typeof alertTypeSchema>;
+type AlertStatus = z.infer<typeof alertStatusSchema>;
+type NotificationChannel = z.infer<typeof notificationChannelSchema>;
+type CreateNotificationChannel = z.infer<typeof createNotificationChannelSchema>;
+type UpdateNotificationChannel = z.infer<typeof updateNotificationChannelSchema>;
+type AlertRule = z.infer<typeof alertRuleSchema>;
+type CreateAlertRule = z.infer<typeof createAlertRuleSchema>;
+type UpdateAlertRule = z.infer<typeof updateAlertRuleSchema>;
+type AlertHistory = z.infer<typeof alertHistorySchema>;
+type TestChannelResponse = z.infer<typeof testChannelResponseSchema>;
+interface ListAlertHistoryOptions {
+    limit?: number;
+}
+
+declare abstract class BaseResource {
+    protected readonly http: KyInstance;
+    constructor(http: KyInstance);
+    protected validate<T>(data: unknown, schema: ZodSchema<T>): T;
+}
+
+declare class AlertChannelsResource extends BaseResource {
+    list(): Promise<NotificationChannel[]>;
+    get(id: number): Promise<NotificationChannel>;
+    create(input: CreateNotificationChannel): Promise<NotificationChannel>;
+    update(id: number, input: UpdateNotificationChannel): Promise<NotificationChannel>;
+    delete(id: number): Promise<void>;
+    test(id: number): Promise<TestChannelResponse>;
+}
+
+declare class AlertRulesResource extends BaseResource {
+    list(projectId: number): Promise<AlertRule[]>;
+    get(projectId: number, ruleId: number): Promise<AlertRule>;
+    create(projectId: number, input: CreateAlertRule): Promise<AlertRule>;
+    update(projectId: number, ruleId: number, input: UpdateAlertRule): Promise<AlertRule>;
+    delete(projectId: number, ruleId: number): Promise<void>;
+    listHistory(projectId: number, options?: ListAlertHistoryOptions): Promise<AlertHistory[]>;
+}
+
+declare const userSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    email: z.ZodString;
+    is_admin: z.ZodBoolean;
+}, z.core.$strip>;
+declare const authResponseSchema: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodNumber;
+        email: z.ZodString;
+        is_admin: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const loginResultSchema: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodNumber;
+        email: z.ZodString;
+        is_admin: z.ZodBoolean;
+    }, z.core.$strip>;
+    cookies: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const loginRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+declare const registerRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+
+type User = z.infer<typeof userSchema>;
+type AuthResponse = z.infer<typeof authResponseSchema>;
+type LoginResult = z.infer<typeof loginResultSchema>;
+type LoginRequest = z.infer<typeof loginRequestSchema>;
+type RegisterRequest = z.infer<typeof registerRequestSchema>;
+
+declare class AuthResource extends BaseResource {
+    register(credentials: RegisterRequest): Promise<LoginResult>;
+    login(credentials: LoginRequest): Promise<LoginResult>;
+    logout(): Promise<string[]>;
+    getCurrentUser(): Promise<User>;
+}
+
+declare const sortOrderSchema: z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>;
+declare const issueSortSchema: z.ZodEnum<{
+    digest_order: "digest_order";
+    last_seen: "last_seen";
+}>;
+declare const issueFilterSchema: z.ZodEnum<{
+    open: "open";
+    resolved: "resolved";
+    muted: "muted";
+    all: "all";
+}>;
+declare const apiErrorSchema: z.ZodObject<{
+    error: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+interface PaginatedResponse<T> {
+    items: T[];
+    next_cursor?: string;
+    has_more: boolean;
+}
+interface OffsetPaginatedResponse<T> {
+    items: T[];
+    total_count: number;
+    page: number;
+    per_page: number;
+    total_pages: number;
+}
+type SortOrder = z.infer<typeof sortOrderSchema>;
+type IssueSort = z.infer<typeof issueSortSchema>;
+type IssueFilter = z.infer<typeof issueFilterSchema>;
+type ApiError = z.infer<typeof apiErrorSchema>;
+interface ListIssuesOptions {
+    page?: number;
+    per_page?: number;
+    sort?: IssueSort;
+    order?: SortOrder;
+    filter?: IssueFilter;
+}
+interface ListEventsOptions {
+    order?: SortOrder;
+    cursor?: string;
+}
+interface ListProjectsOptions {
+    page?: number;
+    per_page?: number;
+    order?: SortOrder;
+}
+
+declare const eventSchema: z.ZodObject<{
+    id: z.ZodString;
+    event_id: z.ZodString;
+    issue_id: z.ZodString;
+    title: z.ZodString;
+    timestamp: z.ZodString;
+    level: z.ZodString;
+    platform: z.ZodString;
+    release: z.ZodString;
+    environment: z.ZodString;
+}, z.core.$strip>;
+declare const eventDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    event_id: z.ZodString;
+    issue_id: z.ZodString;
+    title: z.ZodString;
+    timestamp: z.ZodString;
+    ingested_at: z.ZodString;
+    level: z.ZodString;
+    platform: z.ZodString;
+    release: z.ZodString;
+    environment: z.ZodString;
+    server_name: z.ZodString;
+    sdk_name: z.ZodString;
+    sdk_version: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip>;
+
+type Event = z.infer<typeof eventSchema>;
+type EventDetail = z.infer<typeof eventDetailSchema>;
+
+declare const issueSchema: z.ZodObject<{
+    id: z.ZodString;
+    project_id: z.ZodNumber;
+    short_id: z.ZodString;
+    title: z.ZodString;
+    value: z.ZodString;
+    first_seen: z.ZodString;
+    last_seen: z.ZodString;
+    event_count: z.ZodNumber;
+    level: z.ZodNullable<z.ZodString>;
+    platform: z.ZodNullable<z.ZodString>;
+    is_resolved: z.ZodBoolean;
+    is_muted: z.ZodBoolean;
+}, z.core.$strip>;
+declare const updateIssueStateSchema: z.ZodObject<{
+    is_resolved: z.ZodOptional<z.ZodBoolean>;
+    is_muted: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+
+type Issue = z.infer<typeof issueSchema>;
+type UpdateIssueState = z.infer<typeof updateIssueStateSchema>;
+
+declare const projectSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    slug: z.ZodString;
+    sentry_key: z.ZodString;
+    dsn: z.ZodString;
+    stored_event_count: z.ZodNumber;
+    digested_event_count: z.ZodNumber;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+declare const createProjectSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const updateProjectSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+type Project = z.infer<typeof projectSchema>;
+type CreateProject = z.infer<typeof createProjectSchema>;
+type UpdateProject = z.infer<typeof updateProjectSchema>;
+
+declare const authTokenSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    token_prefix: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    last_used_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const authTokenCreatedSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    token: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+}, z.core.$strip>;
+declare const createAuthTokenSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+type AuthToken = z.infer<typeof authTokenSchema>;
+type AuthTokenCreated = z.infer<typeof authTokenCreatedSchema>;
+type CreateAuthToken = z.infer<typeof createAuthTokenSchema>;
+
+declare class EventsResource extends BaseResource {
+    list(projectId: number, issueId: string, options?: ListEventsOptions): Promise<PaginatedResponse<Event>>;
+    get(projectId: number, issueId: string, eventId: string): Promise<EventDetail>;
+}
+
+declare class IssuesResource extends BaseResource {
+    list(projectId: number, options?: ListIssuesOptions): Promise<OffsetPaginatedResponse<Issue>>;
+    get(projectId: number, issueId: string): Promise<Issue>;
+    updateState(projectId: number, issueId: string, input: UpdateIssueState): Promise<Issue>;
+    delete(projectId: number, issueId: string): Promise<void>;
+}
+
+declare class ProjectsResource extends BaseResource {
+    list(options?: ListProjectsOptions): Promise<OffsetPaginatedResponse<Project>>;
+    get(id: number): Promise<Project>;
+    create(input: CreateProject): Promise<Project>;
+    update(id: number, input: UpdateProject): Promise<Project>;
+    delete(id: number): Promise<void>;
+}
+
+declare class TokensResource extends BaseResource {
+    list(): Promise<AuthToken[]>;
+    get(id: number): Promise<AuthToken>;
+    create(input: CreateAuthToken): Promise<AuthTokenCreated>;
+    delete(id: number): Promise<void>;
+}
+
+declare class RustrakClient {
+    private readonly http;
+    readonly auth: AuthResource;
+    readonly projects: ProjectsResource;
+    readonly issues: IssuesResource;
+    readonly events: EventsResource;
+    readonly tokens: TokensResource;
+    readonly alertChannels: AlertChannelsResource;
+    readonly alertRules: AlertRulesResource;
+    constructor(config: ClientConfig);
+}
+
+declare class RustrakError extends Error {
+    readonly retryable: boolean;
+    readonly statusCode?: number;
+    readonly cause?: Error;
+    constructor(message: string, options?: {
+        retryable?: boolean;
+        statusCode?: number;
+        cause?: Error;
+    });
+}
+
+declare class NetworkError extends RustrakError {
+    constructor(message: string, cause?: Error);
+}
+declare class AuthenticationError extends RustrakError {
+    constructor(message?: string);
+}
+declare class AuthorizationError extends RustrakError {
+    constructor(message?: string);
+}
+declare class NotFoundError extends RustrakError {
+    constructor(resource: string);
+}
+declare class RateLimitError extends RustrakError {
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: string | number);
+}
+declare class ServerError extends RustrakError {
+    constructor(message: string, statusCode?: number);
+}
+declare class BadRequestError extends RustrakError {
+    constructor(message: string);
+}
+
+declare class ValidationError extends RustrakError {
+    readonly validationErrors?: ZodError;
+    constructor(message: string, validationErrors?: ZodError);
+    getValidationDetails(): string;
+}
+
+export { type AlertHistory, type AlertRule, type AlertStatus, type AlertType, type ApiError, type AuthResponse, type AuthToken, type AuthTokenCreated, AuthenticationError, AuthorizationError, BadRequestError, type ChannelType, type ClientConfig, type CreateAlertRule, type CreateAuthToken, type CreateNotificationChannel, type CreateProject, type Event, type EventDetail, type Issue, type IssueFilter, type IssueSort, type ListAlertHistoryOptions, type ListEventsOptions, type ListIssuesOptions, type ListProjectsOptions, type LoginRequest, type LoginResult, NetworkError, NotFoundError, type NotificationChannel, type OffsetPaginatedResponse, type PaginatedResponse, type Project, RateLimitError, type RegisterRequest, RustrakClient, RustrakError, ServerError, type SortOrder, type TestChannelResponse, type UpdateAlertRule, type UpdateIssueState, type UpdateNotificationChannel, type UpdateProject, type User, ValidationError };