@rustrak/client 0.12.3 → 0.14.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { z, ZodSchema, ZodError } from 'zod';
-import { KyInstance } from 'ky';
+import { z, ZodSchema } from 'zod';
+import { KyInstance, ResponsePromise } from 'ky';
 
 interface ClientConfig {
     baseUrl: string;
@@ -9,6 +9,94 @@ interface ClientConfig {
     headers?: Record<string, string>;
 }
 
+type RustrakError = {
+    readonly kind: 'validation';
+    readonly status: number;
+    readonly message: string;
+    readonly fields?: readonly FieldError[];
+} | {
+    readonly kind: 'unauthenticated';
+    readonly status: number;
+    readonly message: string;
+    readonly fields?: readonly FieldError[];
+} | {
+    readonly kind: 'forbidden';
+    readonly status: number;
+    readonly message: string;
+    readonly fields?: readonly FieldError[];
+} | {
+    readonly kind: 'not_found';
+    readonly status: number;
+    readonly message: string;
+    readonly fields?: readonly FieldError[];
+} | {
+    readonly kind: 'conflict';
+    readonly status: number;
+    readonly message: string;
+    readonly fields?: readonly FieldError[];
+} | {
+    readonly kind: 'gone';
+    readonly status: number;
+    readonly message: string;
+    readonly fields?: readonly FieldError[];
+} | {
+    readonly kind: 'payload_too_large';
+    readonly status: number;
+    readonly message: string;
+    readonly fields?: readonly FieldError[];
+} | {
+    readonly kind: 'rate_limited';
+    readonly status: number;
+    readonly message: string;
+    readonly retryAfter?: number;
+    readonly fields?: readonly FieldError[];
+} | {
+    readonly kind: 'client_error';
+    readonly status: number;
+    readonly message: string;
+    readonly fields?: readonly FieldError[];
+} | {
+    readonly kind: 'invalid_request';
+    readonly message: string;
+} | {
+    readonly kind: 'server_error';
+    readonly status: number;
+    readonly message: string;
+    readonly incidentId?: string;
+} | {
+    readonly kind: 'network';
+    readonly message: string;
+    readonly reason: 'timeout' | 'unreachable';
+} | {
+    readonly kind: 'invalid_response';
+    readonly message: string;
+};
+type RustrakErrorKind = RustrakError['kind'];
+declare const FIELD_ERROR_CODES: readonly ["required", "invalid", "already_exists", "too_short", "too_long", "custom"];
+type FieldErrorCode = (typeof FIELD_ERROR_CODES)[number];
+type FieldError = {
+    readonly field: string;
+    readonly code: FieldErrorCode;
+    readonly message?: string;
+};
+declare const SERVER_ERROR_MESSAGE = "The server failed to handle the request.";
+declare const NETWORK_ERROR_MESSAGE = "The request could not reach the server.";
+declare const TIMEOUT_ERROR_MESSAGE = "The request timed out.";
+declare function isRetryable(error: RustrakError): boolean;
+
+type Result<T, E> = {
+    readonly success: true;
+    readonly data: T;
+} | {
+    readonly success: false;
+    readonly error: E;
+};
+declare function Ok<T>(data: T): Result<T, never>;
+declare function Err<E>(error: E): Result<never, E>;
+declare function unwrap<T, E>(result: Result<T, E>): T;
+declare function unwrapOr<T, E>(result: Result<T, E>, fallback: T): T;
+declare function mapResult<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+
 declare const serverVersionSchema: z.ZodObject<{
     version: z.ZodString;
 }, z.core.$strip>;
@@ -183,15 +271,11 @@ declare const testIntegrationBodySchema: z.ZodObject<{
 }, z.core.$strip>;
 
 type ProviderType = z.infer<typeof providerTypeSchema>;
-type ChannelType = ProviderType;
 type AlertType = z.infer<typeof alertTypeSchema>;
 type AlertStatus = z.infer<typeof alertStatusSchema>;
 type AlertIntegration = z.infer<typeof alertIntegrationSchema>;
-type NotificationChannel = AlertIntegration;
 type CreateAlertIntegration = z.infer<typeof createAlertIntegrationSchema>;
-type CreateNotificationChannel = CreateAlertIntegration;
 type UpdateAlertIntegration = z.infer<typeof updateAlertIntegrationSchema>;
-type UpdateNotificationChannel = UpdateAlertIntegration;
 type AlertRuleChannelInput = z.infer<typeof alertRuleChannelInputSchema>;
 type RoutingOverride = Record<string, unknown>;
 type AlertRule = z.infer<typeof alertRuleSchema>;
@@ -256,6 +340,7 @@ interface ListProjectsOptions {
     page?: number;
     per_page?: number;
     order?: SortOrder;
+    stats_period?: string;
 }
 interface ListTransactionsOptions {
     page?: number;
@@ -566,6 +651,19 @@ type ProjectRole = z.infer<typeof projectRoleSchema>;
 type ProjectMember = z.infer<typeof projectMemberSchema>;
 type UpsertProjectMember = z.infer<typeof upsertProjectMemberSchema>;
 
+declare const projectListStatsSchema: z.ZodObject<{
+    trend: z.ZodArray<z.ZodNumber>;
+    events: z.ZodObject<{
+        current: z.ZodNumber;
+        previous: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    new_issues: z.ZodObject<{
+        current: z.ZodNumber;
+        previous: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    open_issues: z.ZodNumber;
+    fatal_issues: z.ZodNumber;
+}, z.core.$strip>;
 declare const projectSchema: z.ZodObject<{
     id: z.ZodNumber;
     name: z.ZodString;
@@ -577,17 +675,33 @@ declare const projectSchema: z.ZodObject<{
     created_at: z.ZodString;
     updated_at: z.ZodString;
     platform: z.ZodNullable<z.ZodString>;
+    stats: z.ZodOptional<z.ZodObject<{
+        trend: z.ZodArray<z.ZodNumber>;
+        events: z.ZodObject<{
+            current: z.ZodNumber;
+            previous: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        new_issues: z.ZodObject<{
+            current: z.ZodNumber;
+            previous: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        open_issues: z.ZodNumber;
+        fatal_issues: z.ZodNumber;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 declare const createProjectSchema: z.ZodObject<{
     name: z.ZodString;
     slug: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const updateProjectSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     platform: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
 type Project = z.infer<typeof projectSchema>;
+type ProjectListStats = z.infer<typeof projectListStatsSchema>;
 type CreateProject = z.infer<typeof createProjectSchema>;
 type UpdateProject = z.infer<typeof updateProjectSchema>;
 
@@ -638,6 +752,11 @@ declare const chunkUploadCapabilitySchema: z.ZodObject<{
     accept: z.ZodArray<z.ZodString>;
     concurrency: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
+declare const assembleInputSchema: z.ZodObject<{
+    checksum: z.ZodString;
+    chunks: z.ZodArray<z.ZodString>;
+    projects: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
 declare const assembleResponseSchema: z.ZodObject<{
     state: z.ZodString;
     missingChunks: z.ZodArray<z.ZodString>;
@@ -664,11 +783,7 @@ type ChunkUploadCapability = z.infer<typeof chunkUploadCapabilitySchema>;
 type AssembleResponse = z.infer<typeof assembleResponseSchema>;
 type SourceMapFile = z.infer<typeof sourceMapFileSchema>;
 type ListSourceMapsResponse = z.infer<typeof listSourceMapsResponseSchema>;
-interface AssembleInput {
-    checksum: string;
-    chunks: string[];
-    projects: string[];
-}
+type AssembleInput = z.infer<typeof assembleInputSchema>;
 
 declare const eventTimeseriesPointSchema: z.ZodObject<{
     bucket: z.ZodString;
@@ -937,169 +1052,175 @@ type RegisterRequest = z.infer<typeof registerRequestSchema>;
 declare abstract class BaseResource {
     protected readonly http: KyInstance;
     constructor(http: KyInstance);
-    protected validate<T>(data: unknown, schema: ZodSchema<T>): T;
+    protected validate<T>(data: unknown, schema: ZodSchema<T>): Result<T, RustrakError>;
+    protected validateInput<T>(input: unknown, schema: ZodSchema<T>): Result<T, RustrakError>;
+    protected requestResponse<T>(send: () => ResponsePromise, read: (response: Response) => Promise<Result<T, RustrakError>>): Promise<Result<T, RustrakError>>;
+    protected readJson(response: Response): Promise<Result<unknown, RustrakError>>;
+    protected request<T>(send: () => ResponsePromise, schema: ZodSchema<T>): Promise<Result<T, RustrakError>>;
+    protected requestVoid(send: () => ResponsePromise): Promise<Result<void, RustrakError>>;
 }
 
 declare class AgentsResource extends BaseResource {
-    getRuns(projectId: number, options?: AgentTimeseriesOptions): Promise<AgentTimeseriesPoint[]>;
-    getDuration(projectId: number, options?: AgentTimeseriesOptions): Promise<AgentDurationPoint[]>;
-    getModelsByCalls(projectId: number, options?: AgentBreakdownOptions): Promise<GenAiBreakdownRow[]>;
-    getModelsByTokens(projectId: number, options?: AgentBreakdownOptions): Promise<GenAiBreakdownRow[]>;
-    getTools(projectId: number, options?: AgentBreakdownOptions): Promise<GenAiBreakdownRow[]>;
-    getTraces(projectId: number, options?: AgentTracesOptions): Promise<OffsetPaginatedResponse<AgentTraceSummary>>;
+    getRuns(projectId: number, options?: AgentTimeseriesOptions): Promise<Result<AgentTimeseriesPoint[], RustrakError>>;
+    getDuration(projectId: number, options?: AgentTimeseriesOptions): Promise<Result<AgentDurationPoint[], RustrakError>>;
+    getModelsByCalls(projectId: number, options?: AgentBreakdownOptions): Promise<Result<GenAiBreakdownRow[], RustrakError>>;
+    getModelsByTokens(projectId: number, options?: AgentBreakdownOptions): Promise<Result<GenAiBreakdownRow[], RustrakError>>;
+    getTools(projectId: number, options?: AgentBreakdownOptions): Promise<Result<GenAiBreakdownRow[], RustrakError>>;
+    getTraces(projectId: number, options?: AgentTracesOptions): Promise<Result<OffsetPaginatedResponse<AgentTraceSummary>, RustrakError>>;
 }
 
 declare class AlertIntegrationsResource extends BaseResource {
-    list(): Promise<AlertIntegration[]>;
-    get(id: number): Promise<AlertIntegration>;
-    create(input: CreateAlertIntegration): Promise<AlertIntegration>;
-    update(id: number, input: UpdateAlertIntegration): Promise<AlertIntegration>;
-    delete(id: number): Promise<void>;
-    test(id: number, routingOverride?: RoutingOverride): Promise<TestChannelResponse>;
+    list(): Promise<Result<AlertIntegration[], RustrakError>>;
+    get(id: number): Promise<Result<AlertIntegration, RustrakError>>;
+    create(input: CreateAlertIntegration): Promise<Result<AlertIntegration, RustrakError>>;
+    update(id: number, input: UpdateAlertIntegration): Promise<Result<AlertIntegration, RustrakError>>;
+    delete(id: number): Promise<Result<void, RustrakError>>;
+    test(id: number, routingOverride?: RoutingOverride): Promise<Result<TestChannelResponse, RustrakError>>;
 }
 
 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[]>;
+    list(projectId: number): Promise<Result<AlertRule[], RustrakError>>;
+    get(projectId: number, ruleId: number): Promise<Result<AlertRule, RustrakError>>;
+    create(projectId: number, input: CreateAlertRule): Promise<Result<AlertRule, RustrakError>>;
+    update(projectId: number, ruleId: number, input: UpdateAlertRule): Promise<Result<AlertRule, RustrakError>>;
+    delete(projectId: number, ruleId: number): Promise<Result<void, RustrakError>>;
+    listHistory(projectId: number, options?: ListAlertHistoryOptions): Promise<Result<AlertHistory[], RustrakError>>;
 }
 
 declare class AuthResource extends BaseResource {
-    register(credentials: RegisterRequest): Promise<LoginResult>;
-    login(credentials: LoginRequest): Promise<LoginResult>;
-    logout(): Promise<string[]>;
-    getCurrentUser(): Promise<User>;
-    getInvitation(token: string): Promise<InvitationInfo>;
-    acceptInvitation(input: AcceptInvitation): Promise<LoginResult>;
+    register(credentials: RegisterRequest): Promise<Result<LoginResult, RustrakError>>;
+    login(credentials: LoginRequest): Promise<Result<LoginResult, RustrakError>>;
+    logout(): Promise<Result<string[], RustrakError>>;
+    getCurrentUser(): Promise<Result<User, RustrakError>>;
+    getInvitation(token: string): Promise<Result<InvitationInfo, RustrakError>>;
+    acceptInvitation(input: AcceptInvitation): Promise<Result<LoginResult, RustrakError>>;
+    private readLoginResult;
 }
 
 declare class EventsResource extends BaseResource {
-    list(projectId: number, issueId: string, options?: ListEventsOptions): Promise<PaginatedResponse<Event>>;
-    get(projectId: number, issueId: string, eventId: string): Promise<EventDetail>;
+    list(projectId: number, issueId: string, options?: ListEventsOptions): Promise<Result<PaginatedResponse<Event>, RustrakError>>;
+    get(projectId: number, issueId: string, eventId: string): Promise<Result<EventDetail, RustrakError>>;
 }
 
 declare class HealthResource extends BaseResource {
-    getVersion(): Promise<ServerVersion>;
+    getVersion(): Promise<Result<ServerVersion, RustrakError>>;
 }
 
 declare class InvitationsResource extends BaseResource {
-    create(input: CreateInvitation): Promise<Invitation>;
-    list(): Promise<Invitation[]>;
-    revoke(token: string): Promise<void>;
+    create(input: CreateInvitation): Promise<Result<Invitation, RustrakError>>;
+    list(): Promise<Result<Invitation[], RustrakError>>;
+    revoke(token: string): Promise<Result<void, RustrakError>>;
 }
 
 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>;
-    resolveInNextRelease(projectId: number, issueId: string): Promise<Issue>;
-    delete(projectId: number, issueId: string): Promise<void>;
-    bulkUpdate(projectId: number, input: BulkUpdateIssues): Promise<{
+    list(projectId: number, options?: ListIssuesOptions): Promise<Result<OffsetPaginatedResponse<Issue>, RustrakError>>;
+    get(projectId: number, issueId: string): Promise<Result<Issue, RustrakError>>;
+    updateState(projectId: number, issueId: string, input: UpdateIssueState): Promise<Result<Issue, RustrakError>>;
+    resolveInNextRelease(projectId: number, issueId: string): Promise<Result<Issue, RustrakError>>;
+    delete(projectId: number, issueId: string): Promise<Result<void, RustrakError>>;
+    bulkUpdate(projectId: number, input: BulkUpdateIssues): Promise<Result<{
         updated: number;
-    }>;
-    bulkDelete(projectId: number, input: BulkDeleteIssues): Promise<{
+    }, RustrakError>>;
+    bulkDelete(projectId: number, input: BulkDeleteIssues): Promise<Result<{
         deleted: number;
-    }>;
-    getHashes(projectId: number, issueId: string): Promise<IssueHash[]>;
-    getTagValues(projectId: number, issueId: string, key: string): Promise<IssueTagValue[]>;
-    getAggregates(projectId: number, issueId: string): Promise<IssueAggregates>;
-    getStats(projectId: number, issueId: string, window?: IssueStatsWindow): Promise<IssueStats>;
-    getActivity(projectId: number, issueId: string): Promise<ActivityEntry[]>;
-    addComment(projectId: number, issueId: string, input: CreateComment): Promise<ActivityEntry>;
-    setBookmark(projectId: number, issueId: string, enabled: boolean): Promise<{
+    }, RustrakError>>;
+    getHashes(projectId: number, issueId: string): Promise<Result<IssueHash[], RustrakError>>;
+    getTagValues(projectId: number, issueId: string, key: string): Promise<Result<IssueTagValue[], RustrakError>>;
+    getAggregates(projectId: number, issueId: string): Promise<Result<IssueAggregates, RustrakError>>;
+    getStats(projectId: number, issueId: string, window?: IssueStatsWindow): Promise<Result<IssueStats, RustrakError>>;
+    getActivity(projectId: number, issueId: string): Promise<Result<ActivityEntry[], RustrakError>>;
+    addComment(projectId: number, issueId: string, input: CreateComment): Promise<Result<ActivityEntry, RustrakError>>;
+    setBookmark(projectId: number, issueId: string, enabled: boolean): Promise<Result<{
         is_bookmarked: boolean;
-    }>;
-    setSubscription(projectId: number, issueId: string, enabled: boolean): Promise<{
+    }, RustrakError>>;
+    setSubscription(projectId: number, issueId: string, enabled: boolean): Promise<Result<{
         is_subscribed: boolean;
-    }>;
-    markSeen(projectId: number, issueId: string): Promise<{
+    }, RustrakError>>;
+    markSeen(projectId: number, issueId: string): Promise<Result<{
         has_seen: boolean;
-    }>;
-    listUserReports(projectId: number, issueId: string): Promise<UserReport[]>;
-    createUserReport(projectId: number, issueId: string, input: CreateUserReport): Promise<UserReport>;
+    }, RustrakError>>;
+    listUserReports(projectId: number, issueId: string): Promise<Result<UserReport[], RustrakError>>;
+    createUserReport(projectId: number, issueId: string, input: CreateUserReport): Promise<Result<UserReport, RustrakError>>;
 }
 
 declare class LogsResource extends BaseResource {
-    list(projectId: number, options?: ListLogsOptions): Promise<OffsetPaginatedResponse<Log>>;
+    list(projectId: number, options?: ListLogsOptions): Promise<Result<OffsetPaginatedResponse<Log>, RustrakError>>;
 }
 
 declare class MembersResource extends BaseResource {
-    list(projectId: number): Promise<ProjectMember[]>;
-    upsert(projectId: number, input: UpsertProjectMember): Promise<void>;
-    remove(projectId: number, userId: number): Promise<void>;
+    list(projectId: number): Promise<Result<ProjectMember[], RustrakError>>;
+    upsert(projectId: number, input: UpsertProjectMember): Promise<Result<void, RustrakError>>;
+    remove(projectId: number, userId: number): Promise<Result<void, RustrakError>>;
 }
 
 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>;
+    list(options?: ListProjectsOptions): Promise<Result<OffsetPaginatedResponse<Project>, RustrakError>>;
+    get(id: number): Promise<Result<Project, RustrakError>>;
+    create(input: CreateProject): Promise<Result<Project, RustrakError>>;
+    update(id: number, input: UpdateProject): Promise<Result<Project, RustrakError>>;
+    delete(id: number): Promise<Result<void, RustrakError>>;
 }
 
 declare class ReleasesResource extends BaseResource {
-    newIssues(projectId: number, release: string, limit?: number): Promise<Issue[]>;
+    newIssues(projectId: number, release: string, limit?: number): Promise<Result<Issue[], RustrakError>>;
 }
 
 declare class SessionsResource extends BaseResource {
-    stats(projectId: number, options?: ReleaseHealthStatsOptions): Promise<OffsetPaginatedResponse<ReleaseHealthRow>>;
-    summary(projectId: number, period?: string): Promise<SessionSummary>;
-    timeseries(projectId: number, period?: string, interval?: number): Promise<SessionTimeseries>;
+    stats(projectId: number, options?: ReleaseHealthStatsOptions): Promise<Result<OffsetPaginatedResponse<ReleaseHealthRow>, RustrakError>>;
+    summary(projectId: number, period?: string): Promise<Result<SessionSummary, RustrakError>>;
+    timeseries(projectId: number, period?: string, interval?: number): Promise<Result<SessionTimeseries, RustrakError>>;
 }
 
 declare class SourceMapsResource extends BaseResource {
-    getChunkUploadCapability(orgSlug: string): Promise<ChunkUploadCapability>;
+    getChunkUploadCapability(orgSlug: string): Promise<Result<ChunkUploadCapability, RustrakError>>;
     uploadChunks(orgSlug: string, chunks: {
         hash: string;
         data: Blob;
-    }[], chunksPerRequest?: number): Promise<void>;
-    assembleBundle(orgSlug: string, input: AssembleInput): Promise<AssembleResponse>;
-    list(orgSlug: string, projectSlug: string): Promise<ListSourceMapsResponse>;
+    }[], chunksPerRequest?: number): Promise<Result<void, RustrakError>>;
+    assembleBundle(orgSlug: string, input: AssembleInput): Promise<Result<AssembleResponse, RustrakError>>;
+    list(orgSlug: string, projectSlug: string): Promise<Result<ListSourceMapsResponse, RustrakError>>;
 }
 
 declare class SpansResource extends BaseResource {
-    list(projectId: number, options?: ListSpansOptions): Promise<OffsetPaginatedResponse<Span>>;
+    list(projectId: number, options?: ListSpansOptions): Promise<Result<OffsetPaginatedResponse<Span>, RustrakError>>;
 }
 
 declare class StatsResource extends BaseResource {
-    timeseries(projectId: number, period?: string, interval?: number): Promise<EventTimeseries>;
-    summary(projectId: number, period?: string): Promise<ProjectStatsSummary>;
+    timeseries(projectId: number, period?: string, interval?: number): Promise<Result<EventTimeseries, RustrakError>>;
+    summary(projectId: number, period?: string): Promise<Result<ProjectStatsSummary, RustrakError>>;
 }
 
 declare class StorageResource extends BaseResource {
-    getSummary(): Promise<StorageSummary>;
-    getProjects(): Promise<ProjectStorage[]>;
-    previewCleanup(options: CleanupOptions): Promise<CleanupCounts>;
-    executeCleanup(options: CleanupOptions): Promise<CleanupCounts>;
-    previewGcSourceMaps(): Promise<SourceMapGcResult>;
-    gcSourceMaps(): Promise<SourceMapGcResult>;
+    getSummary(): Promise<Result<StorageSummary, RustrakError>>;
+    getProjects(): Promise<Result<ProjectStorage[], RustrakError>>;
+    previewCleanup(options: CleanupOptions): Promise<Result<CleanupCounts, RustrakError>>;
+    executeCleanup(options: CleanupOptions): Promise<Result<CleanupCounts, RustrakError>>;
+    previewGcSourceMaps(): Promise<Result<SourceMapGcResult, RustrakError>>;
+    gcSourceMaps(): Promise<Result<SourceMapGcResult, RustrakError>>;
 }
 
 declare class TeamResource extends BaseResource {
-    list(): Promise<TeamMember[]>;
-    updateRole(userId: number, role: GlobalRole): Promise<void>;
-    remove(userId: number): Promise<void>;
+    list(): Promise<Result<TeamMember[], RustrakError>>;
+    updateRole(userId: number, role: GlobalRole): Promise<Result<void, RustrakError>>;
+    remove(userId: number): Promise<Result<void, RustrakError>>;
 }
 
 declare class TokensResource extends BaseResource {
-    list(): Promise<AuthToken[]>;
-    get(id: number): Promise<AuthTokenCreated>;
-    create(input: CreateAuthToken): Promise<AuthTokenCreated>;
-    delete(id: number): Promise<void>;
+    list(): Promise<Result<AuthToken[], RustrakError>>;
+    get(id: number): Promise<Result<AuthTokenCreated, RustrakError>>;
+    create(input: CreateAuthToken): Promise<Result<AuthTokenCreated, RustrakError>>;
+    delete(id: number): Promise<Result<void, RustrakError>>;
 }
 
 declare class TransactionsResource extends BaseResource {
-    list(projectId: number, options?: ListTransactionsOptions): Promise<OffsetPaginatedResponse<Transaction>>;
-    getSpans(projectId: number, transactionId: string): Promise<Span[]>;
+    list(projectId: number, options?: ListTransactionsOptions): Promise<Result<OffsetPaginatedResponse<Transaction>, RustrakError>>;
+    getSpans(projectId: number, transactionId: string): Promise<Result<Span[], RustrakError>>;
     getStats(projectId: number, options?: {
         page?: number;
         per_page?: number;
-    }): Promise<OffsetPaginatedResponse<TransactionStats>>;
-    getStatForGroup(projectId: number, name: string, op?: string): Promise<TransactionStats>;
-    get(projectId: number, transactionId: string): Promise<TransactionDetail>;
+    }): Promise<Result<OffsetPaginatedResponse<TransactionStats>, RustrakError>>;
+    getStatForGroup(projectId: number, name: string, op?: string): Promise<Result<TransactionStats, RustrakError>>;
+    get(projectId: number, transactionId: string): Promise<Result<TransactionDetail, RustrakError>>;
 }
 
 declare class RustrakClient {
@@ -1127,44 +1248,4 @@ declare class RustrakClient {
     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 AcceptInvitation, type ActivityEntry, type AgentBreakdownOptions, type AgentDurationPoint, type AgentTimeseriesOptions, type AgentTimeseriesPoint, type AgentTraceSummary, type AgentTracesOptions, type AlertHistory, type AlertIntegration, type AlertRule, type AlertRuleChannelInput, type AlertStatus, type AlertType, type ApiError, type AssembleInput, type AssembleResponse, type AuthResponse, type AuthToken, type AuthTokenCreated, AuthenticationError, AuthorizationError, BadRequestError, type BulkDeleteIssues, type BulkUpdateIssues, type ChannelType, type ChunkUploadCapability, type CleanupCounts, type CleanupOptions, type ClientConfig, type CreateAlertIntegration, type CreateAlertRule, type CreateAuthToken, type CreateComment, type CreateInvitation, type CreateNotificationChannel, type CreateProject, type CreateUserReport, type Event, type EventDetail, type EventTimeseries, type EventTimeseriesPoint, type GenAiBreakdownRow, type GlobalRole, type Invitation, type InvitationInfo, type Issue, type IssueAggregates, type IssueFilter, type IssueHash, type IssuePriority, type IssueSort, type IssueStats, type IssueStatsWindow, type IssueStatus, type IssueTagValue, type ListAlertHistoryOptions, type ListEventsOptions, type ListIssuesOptions, type ListLogsOptions, type ListProjectsOptions, type ListSourceMapsResponse, type ListSpansOptions, type ListTransactionsOptions, type Log, type LoginRequest, type LoginResult, type MetricDelta, NetworkError, NotFoundError, type NotificationChannel, type OffsetPaginatedResponse, type PaginatedResponse, type Project, type ProjectMember, type ProjectRole, type ProjectStatsSummary, type ProjectStorage, type ProviderType, RateLimitError, type RegisterRequest, type ReleaseHealthRow, type ReleaseHealthStatsOptions, type RoutingOverride, RustrakClient, RustrakError, ServerError, type ServerVersion, type SessionSummary, type SessionTimeseries, type SessionTimeseriesPoint, type SortOrder, type SourceMapFile, type SourceMapGcResult, type SourceMapStorage, type Span, type StorageSummary, type TagSummary, type TagValueCount, type TeamMember, type TestChannelResponse, type TestIntegrationBody, type Transaction, type TransactionDetail, type TransactionStats, type UpdateAlertIntegration, type UpdateAlertRule, type UpdateIssueState, type UpdateNotificationChannel, type UpdateProject, type UpdateUserRole, type UpsertProjectMember, type User, type UserReport, ValidationError };
+export { type AcceptInvitation, type ActivityEntry, type AgentBreakdownOptions, type AgentDurationPoint, type AgentTimeseriesOptions, type AgentTimeseriesPoint, type AgentTraceSummary, type AgentTracesOptions, type AlertHistory, type AlertIntegration, type AlertRule, type AlertRuleChannelInput, type AlertStatus, type AlertType, type ApiError, type AssembleInput, type AssembleResponse, type AuthResponse, type AuthToken, type AuthTokenCreated, type BulkDeleteIssues, type BulkUpdateIssues, type ChunkUploadCapability, type CleanupCounts, type CleanupOptions, type ClientConfig, type CreateAlertIntegration, type CreateAlertRule, type CreateAuthToken, type CreateComment, type CreateInvitation, type CreateProject, type CreateUserReport, Err, type Event, type EventDetail, type EventTimeseries, type EventTimeseriesPoint, FIELD_ERROR_CODES, type FieldError, type FieldErrorCode, type GenAiBreakdownRow, type GlobalRole, type Invitation, type InvitationInfo, type Issue, type IssueAggregates, type IssueFilter, type IssueHash, type IssuePriority, type IssueSort, type IssueStats, type IssueStatsWindow, type IssueStatus, type IssueTagValue, type ListAlertHistoryOptions, type ListEventsOptions, type ListIssuesOptions, type ListLogsOptions, type ListProjectsOptions, type ListSourceMapsResponse, type ListSpansOptions, type ListTransactionsOptions, type Log, type LoginRequest, type LoginResult, type MetricDelta, NETWORK_ERROR_MESSAGE, type OffsetPaginatedResponse, Ok, type PaginatedResponse, type Project, type ProjectListStats, type ProjectMember, type ProjectRole, type ProjectStatsSummary, type ProjectStorage, type ProviderType, type RegisterRequest, type ReleaseHealthRow, type ReleaseHealthStatsOptions, type Result, type RoutingOverride, RustrakClient, type RustrakError, type RustrakErrorKind, SERVER_ERROR_MESSAGE, type ServerVersion, type SessionSummary, type SessionTimeseries, type SessionTimeseriesPoint, type SortOrder, type SourceMapFile, type SourceMapGcResult, type SourceMapStorage, type Span, type StorageSummary, TIMEOUT_ERROR_MESSAGE, type TagSummary, type TagValueCount, type TeamMember, type TestChannelResponse, type TestIntegrationBody, type Transaction, type TransactionDetail, type TransactionStats, type UpdateAlertIntegration, type UpdateAlertRule, type UpdateIssueState, type UpdateProject, type UpdateUserRole, type UpsertProjectMember, type User, type UserReport, isRetryable, mapResult, unwrap, unwrapOr };