@xera-ai/web 0.1.6 → 0.1.7

package/dist/core/src/adapter/types.d.ts

@@ -0,0 +1,69 @@
+import type { Classification } from '../artifact/status';
+import type { XeraConfig } from '../config/schema';
+export interface GenerateInput {
+    ticketDir: string;
+    feature: string;
+    story: string;
+    config: XeraConfig;
+}
+export interface GenerateResult {
+    artifacts: string[];
+    warnings: string[];
+}
+export interface ExecuteInput {
+    ticketDir: string;
+    config: XeraConfig;
+    runId: string;
+    env: string;
+}
+export interface ScenarioResult {
+    name: string;
+    outcome: 'PASS' | 'FAIL' | 'SKIPPED';
+    failure?: {
+        step?: string;
+        errorMessage?: string;
+        domSnapshotAtFailure?: string;
+        networkAtFailure?: Array<{
+            method: string;
+            url: string;
+            status: number;
+        }>;
+        consoleAtFailure?: string[];
+        screenshotPath?: string;
+    };
+}
+export interface RunResult {
+    runId: string;
+    outcome: 'PASS' | 'FAIL';
+    scenarios: ScenarioResult[];
+    artifactsDir: string;
+    rawReportPath: string;
+    normalizedReportPath: string;
+}
+export interface ClassifyContext {
+    history: Array<{
+        ts: string;
+        result: 'PASS' | 'FAIL';
+        class: Classification;
+    }>;
+    storyHashChanged: boolean;
+    specHashChanged: boolean;
+}
+export interface DoctorReport {
+    ok: boolean;
+    checks: Array<{
+        name: string;
+        ok: boolean;
+        message?: string;
+    }>;
+}
+export interface TestAdapter {
+    readonly id: string;
+    generate(input: GenerateInput): Promise<GenerateResult>;
+    execute(input: ExecuteInput): Promise<RunResult>;
+    classify?(run: RunResult, ctx: ClassifyContext): Partial<{
+        class: Classification;
+        rationale: string;
+    }>;
+    doctor(): Promise<DoctorReport>;
+}

package/dist/core/src/artifact/hash.d.ts

@@ -0,0 +1,3 @@
+export declare function hashString(s: string): string;
+export declare function hashFile(path: string): string;
+export declare function hashFileIfExists(path: string): string | null;

package/dist/core/src/artifact/meta.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export declare const MetaJsonSchema: z.ZodObject<{
+    ticket: z.ZodString;
+    adapter: z.ZodString;
+    xera_version: z.ZodString;
+    prompts_version: z.ZodString;
+    fetched_at: z.ZodOptional<z.ZodString>;
+    story_hash: z.ZodOptional<z.ZodString>;
+    feature_generated_at: z.ZodOptional<z.ZodString>;
+    feature_generated_from_story_hash: z.ZodOptional<z.ZodString>;
+    feature_hash: z.ZodOptional<z.ZodString>;
+    script_generated_at: z.ZodOptional<z.ZodString>;
+    script_generated_from_feature_hash: z.ZodOptional<z.ZodString>;
+    script_warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    ticket: string;
+    adapter: string;
+    xera_version: string;
+    prompts_version: string;
+    fetched_at?: string | undefined;
+    story_hash?: string | undefined;
+    feature_generated_at?: string | undefined;
+    feature_generated_from_story_hash?: string | undefined;
+    feature_hash?: string | undefined;
+    script_generated_at?: string | undefined;
+    script_generated_from_feature_hash?: string | undefined;
+    script_warnings?: string[] | undefined;
+}, {
+    ticket: string;
+    adapter: string;
+    xera_version: string;
+    prompts_version: string;
+    fetched_at?: string | undefined;
+    story_hash?: string | undefined;
+    feature_generated_at?: string | undefined;
+    feature_generated_from_story_hash?: string | undefined;
+    feature_hash?: string | undefined;
+    script_generated_at?: string | undefined;
+    script_generated_from_feature_hash?: string | undefined;
+    script_warnings?: string[] | undefined;
+}>;
+export type MetaJson = z.infer<typeof MetaJsonSchema>;
+export declare function readMeta(path: string): MetaJson | null;
+export declare function writeMeta(path: string, meta: MetaJson): void;
+export declare function updateMeta(path: string, patch: Partial<MetaJson>): MetaJson;

package/dist/core/src/artifact/paths.d.ts

@@ -0,0 +1,24 @@
+export interface RunPaths {
+    runDir: string;
+    reportJsonPath: string;
+    tracePath: string;
+    normalizedPath: string;
+    screenshotsDir: string;
+    videoDir: string;
+}
+export interface ArtifactPaths {
+    ticketDir: string;
+    storyPath: string;
+    featurePath: string;
+    specPath: string;
+    pageObjectsDir: string;
+    runsDir: string;
+    metaPath: string;
+    statusPath: string;
+    logPath: string;
+    lockPath: string;
+    authDir: string;
+    runPath: (runId: string) => RunPaths;
+}
+export declare function resolveArtifactPaths(repoRoot: string, ticket: string): ArtifactPaths;
+export declare function generateRunId(now?: Date): string;

package/dist/core/src/artifact/status.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+declare const ClassificationEnum: z.ZodEnum<["PASS", "REAL_BUG", "SELECTOR_DRIFT", "FLAKY", "TEST_BUG"]>;
+export declare const HistoryEntrySchema: z.ZodObject<{
+    ts: z.ZodString;
+    result: z.ZodEnum<["PASS", "FAIL"]>;
+    class: z.ZodEnum<["PASS", "REAL_BUG", "SELECTOR_DRIFT", "FLAKY", "TEST_BUG"]>;
+}, "strip", z.ZodTypeAny, {
+    ts: string;
+    result: "PASS" | "FAIL";
+    class: "PASS" | "REAL_BUG" | "SELECTOR_DRIFT" | "FLAKY" | "TEST_BUG";
+}, {
+    ts: string;
+    result: "PASS" | "FAIL";
+    class: "PASS" | "REAL_BUG" | "SELECTOR_DRIFT" | "FLAKY" | "TEST_BUG";
+}>;
+export declare const StatusJsonSchema: z.ZodObject<{
+    ticket: z.ZodString;
+    lastRun: z.ZodString;
+    result: z.ZodEnum<["PASS", "FAIL"]>;
+    classification: z.ZodEnum<["PASS", "REAL_BUG", "SELECTOR_DRIFT", "FLAKY", "TEST_BUG"]>;
+    confidence: z.ZodEnum<["low", "medium", "high"]>;
+    scenarios: z.ZodObject<{
+        total: z.ZodNumber;
+        passed: z.ZodNumber;
+        failed: z.ZodNumber;
+        skipped: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+    }, {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+    }>;
+    history: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        ts: z.ZodString;
+        result: z.ZodEnum<["PASS", "FAIL"]>;
+        class: z.ZodEnum<["PASS", "REAL_BUG", "SELECTOR_DRIFT", "FLAKY", "TEST_BUG"]>;
+    }, "strip", z.ZodTypeAny, {
+        ts: string;
+        result: "PASS" | "FAIL";
+        class: "PASS" | "REAL_BUG" | "SELECTOR_DRIFT" | "FLAKY" | "TEST_BUG";
+    }, {
+        ts: string;
+        result: "PASS" | "FAIL";
+        class: "PASS" | "REAL_BUG" | "SELECTOR_DRIFT" | "FLAKY" | "TEST_BUG";
+    }>, "many">>;
+    last_jira_comment_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    result: "PASS" | "FAIL";
+    ticket: string;
+    lastRun: string;
+    classification: "PASS" | "REAL_BUG" | "SELECTOR_DRIFT" | "FLAKY" | "TEST_BUG";
+    confidence: "low" | "medium" | "high";
+    scenarios: {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+    };
+    history: {
+        ts: string;
+        result: "PASS" | "FAIL";
+        class: "PASS" | "REAL_BUG" | "SELECTOR_DRIFT" | "FLAKY" | "TEST_BUG";
+    }[];
+    last_jira_comment_id?: string | undefined;
+}, {
+    result: "PASS" | "FAIL";
+    ticket: string;
+    lastRun: string;
+    classification: "PASS" | "REAL_BUG" | "SELECTOR_DRIFT" | "FLAKY" | "TEST_BUG";
+    confidence: "low" | "medium" | "high";
+    scenarios: {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+    };
+    history?: {
+        ts: string;
+        result: "PASS" | "FAIL";
+        class: "PASS" | "REAL_BUG" | "SELECTOR_DRIFT" | "FLAKY" | "TEST_BUG";
+    }[] | undefined;
+    last_jira_comment_id?: string | undefined;
+}>;
+export type StatusJson = z.infer<typeof StatusJsonSchema>;
+export type HistoryEntry = z.infer<typeof HistoryEntrySchema>;
+export type Classification = z.infer<typeof ClassificationEnum>;
+export declare function readStatus(path: string): StatusJson | null;
+export declare function writeStatus(path: string, status: StatusJson): void;
+export declare function appendHistory(path: string, entry: HistoryEntry): StatusJson;
+export {};

package/dist/core/src/auth/encrypt.d.ts

@@ -0,0 +1,3 @@
+export declare function generateKey(): string;
+export declare function encrypt(plaintext: string, keyHex: string): string;
+export declare function decrypt(ciphertext: string, keyHex: string): string;

package/dist/core/src/auth/key.d.ts

@@ -0,0 +1,2 @@
+export declare const AUTH_KEY_ENV = "XERA_AUTH_KEY";
+export declare function resolveAuthKey(): string;

package/dist/core/src/auth/refresh.d.ts

@@ -0,0 +1,8 @@
+import type { AuthStateEntry } from './state';
+export type { AuthStateEntry } from './state';
+export declare function parseDuration(d: string): number;
+export interface RefreshPolicy {
+    ttl: string;
+    refreshBuffer: string;
+}
+export declare function needsRefresh(entry: AuthStateEntry | null, policy: RefreshPolicy, now?: Date): boolean;

package/dist/core/src/auth/state.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const AuthStateEntrySchema: z.ZodObject<{
+    role: z.ZodString;
+    strategy: z.ZodEnum<["storageState", "apiToken"]>;
+    created_at: z.ZodString;
+    expires_at: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "storageState" | "apiToken";
+    role: string;
+    created_at: string;
+    expires_at: string;
+    payload: Record<string, unknown>;
+}, {
+    strategy: "storageState" | "apiToken";
+    role: string;
+    created_at: string;
+    expires_at: string;
+    payload: Record<string, unknown>;
+}>;
+export type AuthStateEntry = z.infer<typeof AuthStateEntrySchema>;
+export declare function writeAuthState(authDir: string, entry: AuthStateEntry): void;
+export declare function readAuthState(authDir: string, role: string): AuthStateEntry | null;

package/dist/core/src/config/define.d.ts

@@ -0,0 +1,2 @@
+import type { XeraConfig } from './schema';
+export declare function defineConfig(config: XeraConfig): XeraConfig;

package/dist/core/src/config/load.d.ts

@@ -0,0 +1,2 @@
+import { type XeraConfig } from './schema';
+export declare function loadConfig(cwd: string): Promise<XeraConfig>;

package/dist/core/src/config/schema.d.ts

@@ -0,0 +1,325 @@
+import { z } from 'zod';
+export declare const XeraConfigSchema: z.ZodObject<{
+    jira: z.ZodObject<{
+        baseUrl: z.ZodString;
+        projectKeys: z.ZodArray<z.ZodString, "many">;
+        fields: z.ZodObject<{
+            story: z.ZodString;
+            acceptanceCriteria: z.ZodOptional<z.ZodString>;
+            attachments: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            story: string;
+            attachments: string;
+            acceptanceCriteria?: string | undefined;
+        }, {
+            story: string;
+            acceptanceCriteria?: string | undefined;
+            attachments?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        baseUrl: string;
+        projectKeys: string[];
+        fields: {
+            story: string;
+            attachments: string;
+            acceptanceCriteria?: string | undefined;
+        };
+    }, {
+        baseUrl: string;
+        projectKeys: string[];
+        fields: {
+            story: string;
+            acceptanceCriteria?: string | undefined;
+            attachments?: string | undefined;
+        };
+    }>;
+    web: z.ZodEffects<z.ZodObject<{
+        baseUrl: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Record<string, string>, Record<string, string>>;
+        defaultEnv: z.ZodString;
+        auth: z.ZodDefault<z.ZodObject<{
+            strategy: z.ZodDefault<z.ZodEnum<["storageState", "apiToken", "none"]>>;
+            ttl: z.ZodDefault<z.ZodString>;
+            refreshBuffer: z.ZodDefault<z.ZodString>;
+            setupScript: z.ZodOptional<z.ZodString>;
+            roles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                envEmail: z.ZodString;
+                envPassword: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                envEmail: string;
+                envPassword: string;
+            }, {
+                envEmail: string;
+                envPassword: string;
+            }>>>;
+        }, "strip", z.ZodTypeAny, {
+            strategy: "storageState" | "apiToken" | "none";
+            ttl: string;
+            refreshBuffer: string;
+            roles: Record<string, {
+                envEmail: string;
+                envPassword: string;
+            }>;
+            setupScript?: string | undefined;
+        }, {
+            strategy?: "storageState" | "apiToken" | "none" | undefined;
+            ttl?: string | undefined;
+            refreshBuffer?: string | undefined;
+            setupScript?: string | undefined;
+            roles?: Record<string, {
+                envEmail: string;
+                envPassword: string;
+            }> | undefined;
+        }>>;
+        testData: z.ZodDefault<z.ZodObject<{
+            users: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                fromAuth: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                fromAuth: string;
+            }, {
+                fromAuth: string;
+            }>>>;
+        }, "strip", z.ZodTypeAny, {
+            users: Record<string, {
+                fromAuth: string;
+            }>;
+        }, {
+            users?: Record<string, {
+                fromAuth: string;
+            }> | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        baseUrl: Record<string, string>;
+        defaultEnv: string;
+        auth: {
+            strategy: "storageState" | "apiToken" | "none";
+            ttl: string;
+            refreshBuffer: string;
+            roles: Record<string, {
+                envEmail: string;
+                envPassword: string;
+            }>;
+            setupScript?: string | undefined;
+        };
+        testData: {
+            users: Record<string, {
+                fromAuth: string;
+            }>;
+        };
+    }, {
+        baseUrl: Record<string, string>;
+        defaultEnv: string;
+        auth?: {
+            strategy?: "storageState" | "apiToken" | "none" | undefined;
+            ttl?: string | undefined;
+            refreshBuffer?: string | undefined;
+            setupScript?: string | undefined;
+            roles?: Record<string, {
+                envEmail: string;
+                envPassword: string;
+            }> | undefined;
+        } | undefined;
+        testData?: {
+            users?: Record<string, {
+                fromAuth: string;
+            }> | undefined;
+        } | undefined;
+    }>, {
+        baseUrl: Record<string, string>;
+        defaultEnv: string;
+        auth: {
+            strategy: "storageState" | "apiToken" | "none";
+            ttl: string;
+            refreshBuffer: string;
+            roles: Record<string, {
+                envEmail: string;
+                envPassword: string;
+            }>;
+            setupScript?: string | undefined;
+        };
+        testData: {
+            users: Record<string, {
+                fromAuth: string;
+            }>;
+        };
+    }, {
+        baseUrl: Record<string, string>;
+        defaultEnv: string;
+        auth?: {
+            strategy?: "storageState" | "apiToken" | "none" | undefined;
+            ttl?: string | undefined;
+            refreshBuffer?: string | undefined;
+            setupScript?: string | undefined;
+            roles?: Record<string, {
+                envEmail: string;
+                envPassword: string;
+            }> | undefined;
+        } | undefined;
+        testData?: {
+            users?: Record<string, {
+                fromAuth: string;
+            }> | undefined;
+        } | undefined;
+    }>;
+    ai: z.ZodDefault<z.ZodObject<{
+        livePageSnapshot: z.ZodDefault<z.ZodBoolean>;
+        confidenceThreshold: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+        maxRetries: z.ZodDefault<z.ZodObject<{
+            typecheck: z.ZodDefault<z.ZodNumber>;
+            lint: z.ZodDefault<z.ZodNumber>;
+            validateFeature: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            typecheck: number;
+            lint: number;
+            validateFeature: number;
+        }, {
+            typecheck?: number | undefined;
+            lint?: number | undefined;
+            validateFeature?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        livePageSnapshot: boolean;
+        confidenceThreshold: "low" | "medium" | "high";
+        maxRetries: {
+            typecheck: number;
+            lint: number;
+            validateFeature: number;
+        };
+    }, {
+        livePageSnapshot?: boolean | undefined;
+        confidenceThreshold?: "low" | "medium" | "high" | undefined;
+        maxRetries?: {
+            typecheck?: number | undefined;
+            lint?: number | undefined;
+            validateFeature?: number | undefined;
+        } | undefined;
+    }>>;
+    reporting: z.ZodDefault<z.ZodObject<{
+        language: z.ZodDefault<z.ZodEnum<["en", "vi"]>>;
+        postToJira: z.ZodDefault<z.ZodBoolean>;
+        transition: z.ZodDefault<z.ZodObject<{
+            onPass: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            onFail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            onPass: string | null;
+            onFail: string | null;
+        }, {
+            onPass?: string | null | undefined;
+            onFail?: string | null | undefined;
+        }>>;
+        artifactLinks: z.ZodDefault<z.ZodEnum<["git", "local"]>>;
+    }, "strip", z.ZodTypeAny, {
+        language: "en" | "vi";
+        postToJira: boolean;
+        transition: {
+            onPass: string | null;
+            onFail: string | null;
+        };
+        artifactLinks: "git" | "local";
+    }, {
+        language?: "en" | "vi" | undefined;
+        postToJira?: boolean | undefined;
+        transition?: {
+            onPass?: string | null | undefined;
+            onFail?: string | null | undefined;
+        } | undefined;
+        artifactLinks?: "git" | "local" | undefined;
+    }>>;
+    adapters: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    jira: {
+        baseUrl: string;
+        projectKeys: string[];
+        fields: {
+            story: string;
+            attachments: string;
+            acceptanceCriteria?: string | undefined;
+        };
+    };
+    web: {
+        baseUrl: Record<string, string>;
+        defaultEnv: string;
+        auth: {
+            strategy: "storageState" | "apiToken" | "none";
+            ttl: string;
+            refreshBuffer: string;
+            roles: Record<string, {
+                envEmail: string;
+                envPassword: string;
+            }>;
+            setupScript?: string | undefined;
+        };
+        testData: {
+            users: Record<string, {
+                fromAuth: string;
+            }>;
+        };
+    };
+    ai: {
+        livePageSnapshot: boolean;
+        confidenceThreshold: "low" | "medium" | "high";
+        maxRetries: {
+            typecheck: number;
+            lint: number;
+            validateFeature: number;
+        };
+    };
+    reporting: {
+        language: "en" | "vi";
+        postToJira: boolean;
+        transition: {
+            onPass: string | null;
+            onFail: string | null;
+        };
+        artifactLinks: "git" | "local";
+    };
+    adapters: string[];
+}, {
+    jira: {
+        baseUrl: string;
+        projectKeys: string[];
+        fields: {
+            story: string;
+            acceptanceCriteria?: string | undefined;
+            attachments?: string | undefined;
+        };
+    };
+    web: {
+        baseUrl: Record<string, string>;
+        defaultEnv: string;
+        auth?: {
+            strategy?: "storageState" | "apiToken" | "none" | undefined;
+            ttl?: string | undefined;
+            refreshBuffer?: string | undefined;
+            setupScript?: string | undefined;
+            roles?: Record<string, {
+                envEmail: string;
+                envPassword: string;
+            }> | undefined;
+        } | undefined;
+        testData?: {
+            users?: Record<string, {
+                fromAuth: string;
+            }> | undefined;
+        } | undefined;
+    };
+    ai?: {
+        livePageSnapshot?: boolean | undefined;
+        confidenceThreshold?: "low" | "medium" | "high" | undefined;
+        maxRetries?: {
+            typecheck?: number | undefined;
+            lint?: number | undefined;
+            validateFeature?: number | undefined;
+        } | undefined;
+    } | undefined;
+    reporting?: {
+        language?: "en" | "vi" | undefined;
+        postToJira?: boolean | undefined;
+        transition?: {
+            onPass?: string | null | undefined;
+            onFail?: string | null | undefined;
+        } | undefined;
+        artifactLinks?: "git" | "local" | undefined;
+    } | undefined;
+    adapters?: string[] | undefined;
+}>;
+export type XeraConfig = z.infer<typeof XeraConfigSchema>;

package/dist/core/src/index.d.ts

@@ -0,0 +1,19 @@
+export declare const VERSION = "0.1.0";
+export type * from './adapter/types';
+export * from './config/schema';
+export * from './config/define';
+export * from './config/load';
+export * from './artifact/paths';
+export * from './artifact/hash';
+export * from './artifact/meta';
+export * from './artifact/status';
+export * from './logging/ndjson-logger';
+export * from './lock/file-lock';
+export * from './jira/types';
+export * from './jira/client';
+export * from './jira/fields';
+export * from './jira/retry';
+export * from './auth/encrypt';
+export * from './auth/key';
+export * from './auth/state';
+export * from './auth/refresh';

package/dist/core/src/jira/client.d.ts

@@ -0,0 +1,10 @@
+import type { JiraClient } from './types';
+export interface CreateJiraClientOptions {
+    baseUrl: string;
+    preferMcp?: boolean;
+    rest?: {
+        email: string;
+        apiToken: string;
+    };
+}
+export declare function createJiraClient(opts: CreateJiraClientOptions): Promise<JiraClient>;

package/dist/core/src/jira/fields.d.ts

@@ -0,0 +1,6 @@
+export interface JiraFieldInfo {
+    id: string;
+    name: string;
+    hasContent: boolean;
+}
+export declare function rankStoryCandidates(fields: JiraFieldInfo[]): JiraFieldInfo[];

package/dist/core/src/jira/mcp-backend.d.ts

@@ -0,0 +1,2 @@
+import type { JiraClient } from './types';
+export declare function createMcpBackend(_baseUrl: string): Promise<JiraClient | null>;

package/dist/core/src/jira/rest-backend.d.ts

@@ -0,0 +1,7 @@
+import type { JiraClient } from './types';
+interface RestCreds {
+    email: string;
+    apiToken: string;
+}
+export declare function createRestBackend(baseUrl: string, creds: RestCreds): JiraClient;
+export {};

package/dist/core/src/jira/retry.d.ts

@@ -0,0 +1,7 @@
+export interface RetryOptions {
+    maxAttempts: number;
+    baseMs: number;
+    factor: number;
+    shouldRetry?: (err: unknown) => boolean;
+}
+export declare function withRetry<T>(fn: () => Promise<T>, opts: RetryOptions): Promise<T>;