@5ive-tech/sdk 1.1.10 → 1.1.13

package/dist/types.d.ts

@@ -18,7 +18,6 @@ export interface ProjectConfig {
     keypairPath?: string;
     optimizations?: ProjectOptimizations;
     dependencies?: ProjectDependency[];
-    multiFileMode?: boolean;
     wasm?: {
         loader?: 'auto' | 'node' | 'bundler';
         modulePaths?: string[];
@@ -80,12 +79,15 @@ export interface CompilationResult {
     metadata?: CompilationMetadata;
     errors?: CompilationError[];
     warnings?: CompilationWarning[];
+    diagnostics?: CompilationError[];
     disassembly?: string[];
     metrics?: CompilationMetrics;
     metricsReport?: CompilationMetricsReport;
     fiveFile?: FiveCompiledFile;
     publicFunctionNames?: string[];
     functionNames?: string[] | FunctionNameEntry[];
+    formattedErrorsTerminal?: string;
+    formattedErrorsJson?: string;
 }
 export interface CompilationMetadata {
     sourceFile: string;
@@ -113,7 +115,16 @@ export interface CompilationError {
     category?: string;
     description?: string;
     location?: any;
-    suggestions?: string[];
+    suggestions?: Array<string | {
+        message: string;
+        explanation?: string;
+        confidence?: number;
+        codeSuggestion?: string;
+    }>;
+    sourceLine?: string;
+    sourceSnippet?: string;
+    rendered?: string;
+    raw?: any;
 }
 export interface CompilationWarning {
     type: string;
@@ -332,12 +343,18 @@ export interface FiveCompiledFile {
 }
 export interface FiveFunction {
     name: string;
+    index?: number;
     parameters: FiveParameter[];
     returnType?: FiveType;
 }
 export interface FiveParameter {
     name: string;
     type: FiveType;
+    param_type?: FiveType;
+    optional?: boolean;
+    is_account?: boolean;
+    isAccount?: boolean;
+    attributes?: string[];
 }
 export type FiveType = string;
 export interface FunctionNameEntry {

package/dist/utils/abi.d.ts

@@ -4,7 +4,11 @@ export interface NormalizedABIFunction {
     parameters: Array<{
         name: string;
         type: string;
+        param_type?: string;
         optional?: boolean;
+        is_account?: boolean;
+        isAccount?: boolean;
+        attributes?: string[];
     }>;
     returnType?: string;
     accounts?: any[];

package/dist/utils/abi.js

@@ -20,8 +20,11 @@ export function normalizeAbiFunctions(abiFunctions) {
             parameters: parameters.map((param, paramIdx) => ({
                 name: param.name ?? `param${paramIdx}`,
                 type: param.type ?? param.param_type ?? param.paramType ?? '',
+                param_type: param.param_type ?? param.paramType,
                 optional: param.optional ?? false,
+                is_account: param.is_account ?? param.isAccount ?? false,
                 isAccount: param.isAccount ?? param.is_account ?? false,
+                attributes: Array.isArray(param.attributes) ? [...param.attributes] : [],
             })),
             returnType: func.returnType ?? func.return_type,
             accounts: func.accounts ?? [],

package/dist/utils/transaction.d.ts

@@ -1,5 +1,27 @@
+export declare const SDK_COMMITMENTS: {
+    readonly WRITE: "confirmed";
+    readonly READ: "finalized";
+    readonly CONFIRM: "finalized";
+};
 export declare function pollForConfirmation(connection: any, signature: string, commitment?: string, timeoutMs?: number, debug?: boolean): Promise<{
     success: boolean;
     err?: any;
     error?: string;
 }>;
+export declare function confirmTransactionRobust(connection: any, signature: string, options?: {
+    commitment?: string;
+    timeoutMs?: number;
+    debug?: boolean;
+    blockhash?: string;
+    lastValidBlockHeight?: number;
+}): Promise<{
+    success: boolean;
+    err?: any;
+    error?: string;
+}>;
+export declare function getAccountInfoWithRetry(connection: any, pubkey: any, options?: {
+    commitment?: string;
+    retries?: number;
+    delayMs?: number;
+    debug?: boolean;
+}): Promise<any | null>;

package/dist/utils/transaction.js

@@ -1,6 +1,40 @@
+export const SDK_COMMITMENTS = {
+    WRITE: "confirmed",
+    READ: "finalized",
+    CONFIRM: "finalized",
+};
+const DEFAULT_POLL_INTERVAL_MS = 1000;
+const DEFAULT_RETRY_DELAY_MS = 700;
+async function sleep(ms) {
+    await new Promise(resolve => setTimeout(resolve, ms));
+}
+function backoffDelayMs(baseMs, attempt) {
+    const exp = Math.min(attempt, 6);
+    const raw = baseMs * (2 ** exp);
+    const jitter = Math.floor(raw * (0.15 * Math.random()));
+    return raw + jitter;
+}
+function normalizeCommitment(commitment) {
+    if (commitment === "finalized")
+        return "finalized";
+    if (commitment === "processed")
+        return "processed";
+    return "confirmed";
+}
+function statusMeetsCommitment(status, confirmations, target) {
+    if (target === "processed") {
+        return !!status || (confirmations ?? 0) >= 0;
+    }
+    if (target === "confirmed") {
+        return status === "confirmed" || status === "finalized" || (confirmations ?? 0) >= 1;
+    }
+    // finalized must be explicitly finalized; confirmations count is insufficient.
+    return status === "finalized";
+}
 export async function pollForConfirmation(connection, signature, commitment = "confirmed", timeoutMs = 120000, debug = false) {
     const startTime = Date.now();
-    const pollIntervalMs = 1000;
+    const pollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
+    const targetCommitment = normalizeCommitment(commitment);
     if (debug) {
         console.log(`[FiveSDK] Starting confirmation poll with ${timeoutMs}ms timeout`);
     }
@@ -11,30 +45,36 @@ export async function pollForConfirmation(connection, signature, commitment = "c
                 console.log(`[FiveSDK] Confirmation status: ${JSON.stringify(confirmationStatus.value)}`);
             }
             if (confirmationStatus.value) {
-                if (confirmationStatus.value.confirmationStatus === commitment ||
-                    confirmationStatus.value.confirmations >= 1) {
-                    const transactionError = confirmationStatus.value.err;
-                    const succeeded = !transactionError;
+                const transactionError = confirmationStatus.value.err;
+                if (transactionError) {
+                    if (debug) {
+                        console.log(`[FiveSDK] Transaction error: ${JSON.stringify(transactionError)}`);
+                    }
+                    return {
+                        success: false,
+                        err: transactionError,
+                        error: JSON.stringify(transactionError),
+                    };
+                }
+                if (statusMeetsCommitment(confirmationStatus.value.confirmationStatus, confirmationStatus.value.confirmations, targetCommitment)) {
+                    const succeeded = true;
                     if (debug) {
                         console.log(`[FiveSDK] Transaction confirmed after ${Date.now() - startTime}ms${succeeded ? '' : ' (with error)'}`);
-                        if (transactionError) {
-                            console.log(`[FiveSDK] Transaction error: ${JSON.stringify(transactionError)}`);
-                        }
                     }
                     return {
                         success: succeeded,
-                        err: transactionError,
-                        error: transactionError ? JSON.stringify(transactionError) : undefined,
+                        err: undefined,
+                        error: undefined,
                     };
                 }
             }
-            await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+            await sleep(pollIntervalMs);
         }
         catch (error) {
             if (debug) {
                 console.log(`[FiveSDK] Polling error: ${error instanceof Error ? error.message : String(error)}`);
             }
-            await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+            await sleep(pollIntervalMs);
         }
     }
     const elapsed = Date.now() - startTime;
@@ -46,3 +86,45 @@ export async function pollForConfirmation(connection, signature, commitment = "c
         error: `Transaction confirmation timeout after ${elapsed}ms. Signature: ${signature}`,
     };
 }
+export async function confirmTransactionRobust(connection, signature, options = {}) {
+    const commitment = options.commitment || SDK_COMMITMENTS.CONFIRM;
+    const timeoutMs = options.timeoutMs || 120000;
+    const debug = options.debug || false;
+    try {
+        const confirmArg = options.blockhash && typeof options.lastValidBlockHeight === "number"
+            ? {
+                signature,
+                blockhash: options.blockhash,
+                lastValidBlockHeight: options.lastValidBlockHeight,
+            }
+            : signature;
+        const confirmation = await connection.confirmTransaction(confirmArg, commitment);
+        const err = confirmation?.value?.err;
+        if (!err) {
+            return { success: true };
+        }
+        return { success: false, err, error: JSON.stringify(err) };
+    }
+    catch (error) {
+        if (debug) {
+            console.log(`[FiveSDK] confirmTransaction threw, falling back to polling: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return pollForConfirmation(connection, signature, commitment, timeoutMs, debug);
+}
+export async function getAccountInfoWithRetry(connection, pubkey, options = {}) {
+    const commitment = options.commitment || SDK_COMMITMENTS.READ;
+    const retries = options.retries ?? 2;
+    const delayMs = options.delayMs ?? DEFAULT_RETRY_DELAY_MS;
+    const debug = options.debug || false;
+    let info = await connection.getAccountInfo(pubkey, commitment);
+    for (let attempt = 0; !info && attempt < retries; attempt++) {
+        const waitMs = backoffDelayMs(delayMs, attempt);
+        if (debug) {
+            console.log(`[FiveSDK] getAccountInfo retry ${attempt + 1}/${retries}, waiting ${waitMs}ms`);
+        }
+        await sleep(waitMs);
+        info = await connection.getAccountInfo(pubkey, commitment);
+    }
+    return info;
+}

package/dist/wasm/compiler/CompilationLogic.d.ts

@@ -1,10 +1,5 @@
 import { CompilationOptions, CompilationResult } from "../../types.js";
 import { CompilationContext } from "./types.js";
 export declare function compile(ctx: CompilationContext, source: string, options?: any): Promise<any>;
-export declare function compileModules(ctx: CompilationContext, mainSource: string, modules: Array<{
-    name: string;
-    source: string;
-}>, options?: any): Promise<any>;
 export declare function compileFile(ctx: CompilationContext, options: CompilationOptions): Promise<CompilationResult>;
 export declare function compileWithDiscovery(ctx: CompilationContext, entryPoint: string, options?: any): Promise<any>;
-export declare function compileModulesExplicit(ctx: CompilationContext, moduleFiles: string[], entryPoint: string, options?: any): Promise<any>;

package/dist/wasm/compiler/CompilationLogic.js

@@ -1,5 +1,5 @@
 import { readFile, writeFile } from "fs/promises";
-import { createCompilerError, extractMetrics, extractAbi } from "./utils.js";
+import { createCompilerError, extractMetrics, extractAbi, extractFormattedErrors, extractDiagnostics, } from "./utils.js";
 export async function compile(ctx, source, options) {
     if (!ctx.compiler) {
         throw createCompilerError("Compiler not initialized");
@@ -25,7 +25,8 @@ export async function compile(ctx, source, options) {
             .with_metrics(includeMetrics)
             .with_comprehensive_metrics(comprehensiveMetrics)
             .with_metrics_format(metricsFormat)
-            .with_error_format(errorFormat);
+            .with_error_format(errorFormat)
+            .with_source_file(options?.sourceFile || "input.v");
         result = ctx.compiler.compile(source, compilationOptions);
         if (result.compiler_errors && result.compiler_errors.length > 0) {
             ctx.logger.debug(`WASM returned ${result.compiler_errors.length} compiler errors`);
@@ -50,6 +51,8 @@ export async function compile(ctx, source, options) {
             }
         }
         const metricsPayload = extractMetrics(result, metricsFormat);
+        const formattedErrors = extractFormattedErrors(result);
+        const diagnostics = extractDiagnostics(result, ctx.logger);
         if (result.success && result.bytecode) {
             return {
                 success: true,
@@ -58,79 +61,33 @@ export async function compile(ctx, source, options) {
                 metadata: result.metadata,
                 metrics: metricsPayload,
                 metricsReport: metricsPayload,
+                formattedErrorsTerminal: formattedErrors.terminal,
+                formattedErrorsJson: formattedErrors.json,
             };
         }
         else {
             return {
                 success: false,
-                errors: result.compiler_errors || [],
+                errors: diagnostics,
+                warnings: diagnostics.filter((diag) => diag.severity === "warning"),
+                diagnostics,
                 metadata: result.metadata,
                 metrics: metricsPayload,
                 metricsReport: metricsPayload,
+                formattedErrorsTerminal: formattedErrors.terminal,
+                formattedErrorsJson: formattedErrors.json,
             };
         }
     }
     catch (error) {
-        if (options && options.debug) { // Check if debug option is available, though not strictly in CompilationOptions type used here as any
-            // Actually 'options' is any in signature
+        if (error &&
+            typeof error === "object" &&
+            error.code === "COMPILER_ERROR") {
+            throw error;
         }
-        // Logic from original code had specialized try/catch for WASM error inside compileFile
-        // but here in compile it just throws
-        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error);
-    }
-}
-export async function compileModules(ctx, mainSource, modules, options) {
-    if (!ctx.compiler) {
-        throw createCompilerError("Compiler not initialized");
-    }
-    const startTime = Date.now();
-    try {
-        let WasmCompilationOptions = ctx.WasmCompilationOptions;
-        if (!WasmCompilationOptions && ctx.wasmModuleRef) {
-            WasmCompilationOptions = ctx.wasmModuleRef.WasmCompilationOptions;
-        }
-        const metricsFormat = options?.metricsFormat || "json";
-        const includeMetrics = options?.includeMetrics || Boolean(options?.metricsOutput);
-        const errorFormat = options?.errorFormat || "terminal";
-        const comprehensiveMetrics = options?.comprehensiveMetrics || false;
-        const compilationOptions = new WasmCompilationOptions()
-            .with_mode(options?.target || "deployment")
-            .with_optimization_level(options?.optimizationLevel || "production")
-            .with_v2_preview(true)
-            .with_constraint_cache(false)
-            .with_enhanced_errors(true)
-            .with_metrics(includeMetrics)
-            .with_comprehensive_metrics(comprehensiveMetrics)
-            .with_metrics_format(metricsFormat)
-            .with_error_format(errorFormat);
-        const result = ctx.compiler.compile_multi(mainSource, modules, compilationOptions);
-        const metricsPayload = extractMetrics(result, metricsFormat);
-        if (result.success && result.bytecode) {
-            return {
-                success: true,
-                bytecode: result.bytecode,
-                abi: extractAbi(result, ctx.logger),
-                metadata: result.metadata,
-                metrics: metricsPayload,
-                metricsReport: metricsPayload,
-            };
-        }
-        else {
-            return {
-                success: false,
-                errors: result.compiler_errors || [],
-                metadata: result.metadata,
-                metrics: metricsPayload,
-                metricsReport: metricsPayload,
-            };
-        }
-    }
-    catch (error) {
-        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error);
-    }
-    finally {
-        const compilationTime = Date.now() - startTime;
-        ctx.logger.debug(`Multi-file compilation completed in ${compilationTime}ms`);
+        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error, {
+            phase: "compile",
+        });
     }
 }
 export async function compileFile(ctx, options) {
@@ -233,60 +190,17 @@ export async function compileFile(ctx, options) {
         }
         const compilationTime = Date.now() - startTime;
         const metricsPayload = extractMetrics(result, metricsFormat);
-        let convertedErrors = [];
-        if (result.compiler_errors && result.compiler_errors.length > 0) {
-            try {
-                const jsonErrors = result.format_all_json
-                    ? result.format_all_json()
-                    : null;
-                if (jsonErrors) {
-                    const parsedErrors = JSON.parse(jsonErrors);
-                    convertedErrors = parsedErrors.map((error) => ({
-                        type: "enhanced",
-                        ...error,
-                        code: error.code || "E0000",
-                        severity: error.severity || "error",
-                        category: error.category || "compilation",
-                        message: error.message || "Unknown error",
-                    }));
-                }
-                else {
-                    convertedErrors = [
-                        {
-                            type: "enhanced",
-                            code: "E0004",
-                            severity: "error",
-                            category: "compilation",
-                            message: "InvalidScript",
-                            description: "The script contains syntax or semantic errors",
-                            location: undefined,
-                            suggestions: [],
-                        },
-                    ];
-                }
-            }
-            catch (parseError) {
-                ctx.logger.debug("Failed to parse JSON errors from WASM:", parseError);
-                convertedErrors = [
-                    {
-                        type: "enhanced",
-                        code: "E0004",
-                        severity: "error",
-                        category: "compilation",
-                        message: "InvalidScript",
-                        description: "Compilation failed with enhanced error system",
-                        location: undefined,
-                        suggestions: [],
-                    },
-                ];
-            }
-        }
+        const formattedErrors = extractFormattedErrors(result);
+        const diagnostics = extractDiagnostics(result, ctx.logger);
         const compilationResult = {
             success: result.success,
             bytecode: result.bytecode ? new Uint8Array(result.bytecode) : undefined,
             abi: result.abi || undefined,
-            errors: convertedErrors,
-            warnings: convertedErrors.filter((e) => e.severity === "warning") || [],
+            errors: diagnostics,
+            warnings: diagnostics.filter((diag) => diag.severity === "warning"),
+            diagnostics,
+            formattedErrorsTerminal: formattedErrors.terminal,
+            formattedErrorsJson: formattedErrors.json,
             metrics: {
                 compilationTime: result.compilation_time || compilationTime,
                 bytecodeSize: result.bytecode_size || 0,
@@ -353,9 +267,12 @@ export async function compileWithDiscovery(ctx, entryPoint, options) {
             .with_metrics(includeMetrics)
             .with_comprehensive_metrics(comprehensiveMetrics)
             .with_metrics_format(metricsFormat)
-            .with_error_format(errorFormat);
+            .with_error_format(errorFormat)
+            .with_source_file(entryPoint);
         const result = ctx.compiler.compileMultiWithDiscovery(entryPoint, compilationOptions);
         const metricsPayload = extractMetrics(result, metricsFormat);
+        const formattedErrors = extractFormattedErrors(result);
+        const diagnostics = extractDiagnostics(result, ctx.logger);
         if (result.success && result.bytecode) {
             return {
                 success: true,
@@ -364,68 +281,33 @@ export async function compileWithDiscovery(ctx, entryPoint, options) {
                 metadata: result.metadata,
                 metrics: metricsPayload,
                 metricsReport: metricsPayload,
+                formattedErrorsTerminal: formattedErrors.terminal,
+                formattedErrorsJson: formattedErrors.json,
             };
         }
         else {
             return {
                 success: false,
-                errors: result.compiler_errors || [],
+                errors: diagnostics,
+                warnings: diagnostics.filter((diag) => diag.severity === "warning"),
+                diagnostics,
                 metadata: result.metadata,
                 metrics: metricsPayload,
                 metricsReport: metricsPayload,
+                formattedErrorsTerminal: formattedErrors.terminal,
+                formattedErrorsJson: formattedErrors.json,
             };
         }
     }
     catch (error) {
-        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error);
-    }
-}
-export async function compileModulesExplicit(ctx, moduleFiles, entryPoint, options) {
-    if (!ctx.compiler) {
-        throw createCompilerError("Compiler not initialized");
-    }
-    try {
-        let WasmCompilationOptions = ctx.WasmCompilationOptions;
-        if (!WasmCompilationOptions && ctx.wasmModuleRef) {
-            WasmCompilationOptions = ctx.wasmModuleRef.WasmCompilationOptions;
+        if (error &&
+            typeof error === "object" &&
+            error.code === "COMPILER_ERROR") {
+            throw error;
         }
-        const metricsFormat = options?.metricsFormat || "json";
-        const includeMetrics = options?.includeMetrics || Boolean(options?.metricsOutput);
-        const errorFormat = options?.errorFormat || "terminal";
-        const comprehensiveMetrics = options?.comprehensiveMetrics || false;
-        const compilationOptions = new WasmCompilationOptions()
-            .with_mode(options?.target || "deployment")
-            .with_optimization_level(options?.optimizationLevel || "production")
-            .with_v2_preview(true)
-            .with_constraint_cache(false)
-            .with_enhanced_errors(true)
-            .with_metrics(includeMetrics)
-            .with_comprehensive_metrics(comprehensiveMetrics)
-            .with_metrics_format(metricsFormat)
-            .with_error_format(errorFormat);
-        const result = ctx.compiler.compileModules(moduleFiles, entryPoint, compilationOptions);
-        const metricsPayload = extractMetrics(result, metricsFormat);
-        if (result.success && result.bytecode) {
-            return {
-                success: true,
-                bytecode: result.bytecode,
-                abi: result.abi,
-                metadata: result.metadata,
-                metrics: metricsPayload,
-                metricsReport: metricsPayload,
-            };
-        }
-        else {
-            return {
-                success: false,
-                errors: result.compiler_errors || [],
-                metadata: result.metadata,
-                metrics: metricsPayload,
-                metricsReport: metricsPayload,
-            };
-        }
-    }
-    catch (error) {
-        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error);
+        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error, {
+            phase: "compileWithDiscovery",
+            entryPoint,
+        });
     }
 }

package/dist/wasm/compiler/FiveCompiler.d.ts

@@ -17,13 +17,8 @@ export declare class FiveCompiler {
     initialize(): Promise<void>;
     private getContext;
     compile(source: string, options?: any): Promise<any>;
-    compileModules(mainSource: string, modules: Array<{
-        name: string;
-        source: string;
-    }>, options?: any): Promise<any>;
     compileFile(options: CompilationOptions): Promise<CompilationResult>;
     compileWithDiscovery(entryPoint: string, options?: any): Promise<any>;
-    compileModulesExplicit(moduleFiles: string[], entryPoint: string, options?: any): Promise<any>;
     generateABI(sourceCode: string): Promise<any>;
     extractAccountDefinitions(sourceCode: string): Promise<any>;
     extractFunctionSignatures(sourceCode: string): Promise<any>;

package/dist/wasm/compiler/FiveCompiler.js

@@ -121,18 +121,12 @@ export class FiveCompiler {
     async compile(source, options) {
         return CompilationLogic.compile(this.getContext(), source, options);
     }
-    async compileModules(mainSource, modules, options) {
-        return CompilationLogic.compileModules(this.getContext(), mainSource, modules, options);
-    }
     async compileFile(options) {
         return CompilationLogic.compileFile(this.getContext(), options);
     }
     async compileWithDiscovery(entryPoint, options) {
         return CompilationLogic.compileWithDiscovery(this.getContext(), entryPoint, options);
     }
-    async compileModulesExplicit(moduleFiles, entryPoint, options) {
-        return CompilationLogic.compileModulesExplicit(this.getContext(), moduleFiles, entryPoint, options);
-    }
     // --- ABI & Extraction ---
     async generateABI(sourceCode) {
         return AbiLogic.generateABI(this.getContext(), sourceCode);

package/dist/wasm/compiler/utils.d.ts

@@ -1,5 +1,38 @@
 import { CLIError } from "../../types.js";
-export declare function createCompilerError(message: string, cause?: Error): CLIError;
+export interface NormalizedCompilationSuggestion {
+    message: string;
+    explanation?: string;
+    confidence?: number;
+    codeSuggestion?: string;
+}
+export interface NormalizedCompilationDiagnostic {
+    type: string;
+    code: string;
+    severity: string;
+    category: string;
+    message: string;
+    description?: string;
+    line?: number;
+    column?: number;
+    sourceLocation?: string;
+    location?: any;
+    suggestion?: string;
+    suggestions?: NormalizedCompilationSuggestion[];
+    sourceLine?: string;
+    sourceSnippet?: string;
+    rendered?: string;
+    raw?: any;
+}
+export interface FormattedErrors {
+    terminal?: string;
+    json?: string;
+}
+export declare function createCompilerError(message: string, cause?: Error, details?: Record<string, unknown>): CLIError;
+export declare function extractFormattedErrors(result: any): FormattedErrors;
+export declare function normalizeDiagnostic(error: any): NormalizedCompilationDiagnostic;
+export declare function extractDiagnostics(result: any, logger?: {
+    debug?: (...args: any[]) => void;
+}): NormalizedCompilationDiagnostic[];
 export declare function extractMetrics(result: any, defaultFormat: string): {
     format: string;
     exported: string;