import { Defined, Simplify, UnionToIntersection } from "../util.mjs";
import { Transaction } from "@mysten/sui/transactions";

//#region src/transaction-analyzer/analyzer.d.ts
/**
 * Declare a dependency on `analyzer` that does NOT short-circuit the parent when
 * it fails: the parent always runs and receives the dependency's full
 * {@link AnalyzerResult} (so it can inspect `status`/`issues`) rather than the
 * unwrapped result. Sugar for `{ analyzer, required: false, transform: (r) => r }`
 * — see {@link Dependency} for the general (required + custom `transform`) form.
 */
declare function optional<T extends Defined, Options, Analysis extends Record<string, Defined>>(analyzer: Analyzer<T, Options, Analysis>): Dependency<T, AnalyzerResult<T>, Options, Analysis>;
declare function createAnalyzer<T extends Defined, Deps extends Record<string, AnalyzerDependency> = {}, Options = object>({
  cacheKey,
  dependencies,
  analyze
}: {
  cacheKey?: unknown;
  dependencies?: Deps;
  analyze: (options: Options, transaction: Transaction) => (analysis: { [k in keyof Deps]: DependencyResult<Deps[k]> }) => Promise<AnalyzerOutput<T>> | AnalyzerOutput<T>;
}): Analyzer<T, Simplify<UnionToIntersection<Options | { [k in keyof Deps]: DependencyOptions<Deps[k]> }[keyof Deps]>>, { [k in keyof Deps]: DependencyResult<Deps[k]> }>;
type OptionsFromAnalyzers<T extends Record<string, Analyzer<Defined, any, any>>> = Simplify<{ [K in keyof T]: T[K] extends Analyzer<Defined, infer O, any> ? O : never }[keyof T] & {
  transaction: string | Uint8Array;
}>;
declare function analyze<T extends Record<string, Analyzer<Defined, any, any>>>(analyzers: T, {
  transaction,
  ...options
}: OptionsFromAnalyzers<T>): Promise<{ [k in keyof T]: T[k] extends Analyzer<infer R extends Defined, any, any> ? AnalyzerResult<R> : never } & {
  issues: TransactionAnalysisIssue[];
  status: AnalyzeStatus;
}>;
/**
 * A dependency edge. A bare {@link Analyzer} is sugar for a required edge whose
 * value is the unwrapped result. The explicit object form lets you declare an
 * edge `required: false` (the parent never short-circuits on it) and/or map the
 * dependency's full {@link AnalyzerResult} to a custom value via `transform`.
 * An optional edge without a `transform` receives the full {@link AnalyzerResult}.
 */
interface Dependency<R$1 extends Defined, V extends Defined = R$1, Options = object, Analysis extends Record<string, Defined> = {}> {
  analyzer: Analyzer<R$1, Options, Analysis>;
  /** Whether a failed/skipped dependency short-circuits the parent. Default: `true`. */
  required?: boolean;
  /**
   * Maps the dependency's full result to the value the parent sees. Default:
   * `(r) => r.result` for required edges and `(r) => r` for optional edges.
   */
  transform?: (result: AnalyzerResult<R$1>) => V;
}
type AnalyzerDependency = Analyzer<Defined, any, any> | Dependency<any, Defined, any, any>;
type DependencyResult<T extends AnalyzerDependency> = T extends {
  transform: (result: AnalyzerResult<any>) => infer V;
} ? V : T extends {
  analyzer: Analyzer<infer R, any, any>;
  required: false;
  transform?: undefined;
} ? AnalyzerResult<R> : T extends Dependency<any, infer V, any, any> ? V : T extends Analyzer<infer R, any, any> ? R : never;
type DependencyOptions<T extends AnalyzerDependency> = T extends Dependency<any, any, infer O, any> ? O : T extends Analyzer<any, infer O, any> ? O : never;
type AnalyzerStatus = 'success' | 'partial' | 'failed' | 'skipped';
type AnalyzeStatus = 'complete' | 'partial' | 'failed';
type Analyzer<T extends Defined, Options = object, Analysis extends Record<string, Defined> = {}> = {
  cacheKey?: unknown;
  dependencies: AnalyzerDependencies<Analysis>;
  analyze: (options: Options, transaction: Transaction) => (analysis: Analysis) => AnalyzerOutput<T> | Promise<AnalyzerOutput<T>>;
};
type IsAny<T> = 0 extends 1 & T ? true : false;
type AnalyzerDependencies<Analysis extends Record<string, Defined>> = IsAny<Analysis> extends true ? Record<string, AnalyzerDependency> : { [K in keyof Analysis]: AnalyzerDependency } & Record<string, AnalyzerDependency>;
type AnalyzerOutput<T extends Defined = Defined> = {
  result: T;
  issues?: TransactionAnalysisIssue[];
} | {
  issues: TransactionAnalysisIssue[];
  result?: never;
};
type AnalyzerResult<T extends Defined = Defined> = {
  status: 'success';
  result: T;
  issues?: never;
  ownIssues?: never;
} | {
  status: 'partial';
  result: T;
  issues: TransactionAnalysisIssue[];
  ownIssues: TransactionAnalysisIssue[];
} | {
  status: 'failed';
  result?: never;
  issues: TransactionAnalysisIssue[];
  ownIssues: TransactionAnalysisIssue[];
} | {
  status: 'skipped';
  result?: never;
  issues: TransactionAnalysisIssue[];
  ownIssues: [];
};
interface TransactionAnalysisIssue {
  message: string;
  error?: Error;
}
//#endregion
export { AnalyzeStatus, Analyzer, AnalyzerDependency, AnalyzerOutput, AnalyzerResult, AnalyzerStatus, Dependency, TransactionAnalysisIssue, analyze, createAnalyzer, optional };
//# sourceMappingURL=analyzer.d.mts.map