@loadstrike/loadstrike-sdk 0.1.0

package/dist/types/runtime.d.ts

@@ -0,0 +1,1052 @@
+import type { LoadStrikeRunRequest } from "./contracts.js";
+export declare const LoadStrikeNodeType: {
+    readonly SingleNode: "SingleNode";
+    readonly Coordinator: "Coordinator";
+    readonly Agent: "Agent";
+};
+export type LoadStrikeNodeType = typeof LoadStrikeNodeType[keyof typeof LoadStrikeNodeType];
+type LoadStrikeNodeTypeInput = LoadStrikeNodeType | "Single";
+export declare const LoadStrikeReportFormat: {
+    readonly Txt: "Txt";
+    readonly Html: "Html";
+    readonly Csv: "Csv";
+    readonly Md: "Md";
+};
+export type LoadStrikeReportFormat = typeof LoadStrikeReportFormat[keyof typeof LoadStrikeReportFormat] | Lowercase<typeof LoadStrikeReportFormat[keyof typeof LoadStrikeReportFormat]>;
+export declare const LoadStrikeLogLevel: {
+    readonly Verbose: "Verbose";
+    readonly Debug: "Debug";
+    readonly Information: "Information";
+    readonly Warning: "Warning";
+    readonly Error: "Error";
+    readonly Fatal: "Fatal";
+};
+export type LoadStrikeLogLevel = typeof LoadStrikeLogLevel[keyof typeof LoadStrikeLogLevel];
+export declare const LoadStrikeScenarioOperation: {
+    readonly Init: "Init";
+    readonly Clean: "Clean";
+    readonly WarmUp: "WarmUp";
+    readonly Bombing: "Bombing";
+};
+export type LoadStrikeScenarioOperation = typeof LoadStrikeScenarioOperation[keyof typeof LoadStrikeScenarioOperation];
+export declare const LoadStrikeOperationType: {
+    readonly None: "None";
+    readonly Init: "Init";
+    readonly WarmUp: "WarmUp";
+    readonly Bombing: "Bombing";
+    readonly Stop: "Stop";
+    readonly Complete: "Complete";
+    readonly Error: "Error";
+};
+export type LoadStrikeOperationType = typeof LoadStrikeOperationType[keyof typeof LoadStrikeOperationType];
+export type LoadStrikeLoadSimulation = Record<string, unknown>;
+export type CrossPlatformTrackingConfiguration = Record<string, unknown>;
+export interface LoadStrikeRandom {
+    next(): number;
+    next(maxValue: number): number;
+    next(minValue: number, maxValue: number): number;
+    Next(): number;
+    Next(maxValue: number): number;
+    Next(minValue: number, maxValue: number): number;
+    nextDouble(): number;
+    NextDouble(): number;
+    sample(): number;
+    Sample(): number;
+    nextBytes(length: number): Uint8Array;
+    NextBytes(length: number): Uint8Array;
+}
+export interface LoadStrikeStepReply<TPayload = unknown> {
+    isSuccess: boolean;
+    statusCode: string;
+    message: string;
+    sizeBytes: number;
+    customLatencyMs?: number;
+    payload?: TPayload;
+    asReply?: () => LoadStrikeStepReply;
+    AsReply?: () => LoadStrikeStepReply;
+    readonly IsError?: boolean;
+    readonly StatusCode?: string;
+    readonly Message?: string;
+    readonly SizeBytes?: number;
+    readonly CustomLatencyMs?: number;
+    readonly Payload?: TPayload;
+}
+export type LoadStrikeReply<TPayload = unknown> = LoadStrikeStepReply<TPayload>;
+export interface LoadStrikeStepRuntime {
+    scenarioName: string;
+    stepName: string;
+    okCount: number;
+    failCount: number;
+    requestCount: number;
+    totalBytes: number;
+    totalLatencyMs: number;
+    avgLatencyMs: number;
+    minLatencyMs: number;
+    maxLatencyMs: number;
+    statusCodes: Record<string, number>;
+}
+export interface LoadStrikeScenarioRuntime {
+    scenarioName: string;
+    allRequestCount: number;
+    allOkCount: number;
+    allFailCount: number;
+    totalBytes: number;
+    totalLatencyMs: number;
+    avgLatencyMs: number;
+    minLatencyMs: number;
+    maxLatencyMs: number;
+    statusCodes: Record<string, number>;
+}
+export interface LoadStrikeMetricValue {
+    name: string;
+    type: "counter" | "gauge";
+    value: number;
+    scenarioName?: string;
+    unitOfMeasure?: string;
+    readonly Name?: string;
+    readonly Type?: "counter" | "gauge";
+    readonly Value?: number;
+    readonly ScenarioName?: string;
+    readonly UnitOfMeasure?: string;
+}
+export interface LoadStrikeCounterStats {
+    metricName: string;
+    scenarioName: string;
+    unitOfMeasure: string;
+    value: number;
+    readonly MetricName?: string;
+    readonly ScenarioName?: string;
+    readonly UnitOfMeasure?: string;
+    readonly Value?: number;
+}
+export interface LoadStrikeGaugeStats {
+    metricName: string;
+    scenarioName: string;
+    unitOfMeasure: string;
+    value: number;
+    readonly MetricName?: string;
+    readonly ScenarioName?: string;
+    readonly UnitOfMeasure?: string;
+    readonly Value?: number;
+}
+export interface LoadStrikeMetricStats {
+    counters: LoadStrikeCounterStats[];
+    gauges: LoadStrikeGaugeStats[];
+    durationMs: number;
+    readonly Counters?: LoadStrikeCounterStats[];
+    readonly Gauges?: LoadStrikeGaugeStats[];
+    readonly DurationMs?: number;
+    readonly Duration?: number;
+}
+export interface LoadStrikeRequestStats {
+    count: number;
+    percent: number;
+    rps: number;
+    readonly Count?: number;
+    readonly Percent?: number;
+    readonly RPS?: number;
+}
+export interface LoadStrikeDataTransferStats {
+    allBytes: number;
+    maxBytes: number;
+    meanBytes: number;
+    minBytes: number;
+    percent50: number;
+    percent75: number;
+    percent95: number;
+    percent99: number;
+    stdDev: number;
+    readonly AllBytes?: number;
+    readonly MaxBytes?: number;
+    readonly MeanBytes?: number;
+    readonly MinBytes?: number;
+    readonly Percent50?: number;
+    readonly Percent75?: number;
+    readonly Percent95?: number;
+    readonly Percent99?: number;
+    readonly StdDev?: number;
+}
+export interface LoadStrikeLatencyCount {
+    lessOrEq800: number;
+    more800Less1200: number;
+    moreOrEq1200: number;
+    readonly LessOrEq800?: number;
+    readonly More800Less1200?: number;
+    readonly MoreOrEq1200?: number;
+}
+export interface LoadStrikeLatencyStats {
+    latencyCount: LoadStrikeLatencyCount;
+    maxMs: number;
+    meanMs: number;
+    minMs: number;
+    percent50: number;
+    percent75: number;
+    percent95: number;
+    percent99: number;
+    stdDev: number;
+    readonly LatencyCount?: LoadStrikeLatencyCount;
+    readonly MaxMs?: number;
+    readonly MeanMs?: number;
+    readonly MinMs?: number;
+    readonly Percent50?: number;
+    readonly Percent75?: number;
+    readonly Percent95?: number;
+    readonly Percent99?: number;
+    readonly StdDev?: number;
+}
+export interface LoadStrikeStatusCodeStats {
+    count: number;
+    isError: boolean;
+    message: string;
+    percent: number;
+    statusCode: string;
+    readonly Count?: number;
+    readonly IsError?: boolean;
+    readonly Message?: string;
+    readonly Percent?: number;
+    readonly StatusCode?: string;
+}
+export interface LoadStrikeMeasurementStats {
+    dataTransfer: LoadStrikeDataTransferStats;
+    latency: LoadStrikeLatencyStats;
+    request: LoadStrikeRequestStats;
+    statusCodes: LoadStrikeStatusCodeStats[];
+    readonly DataTransfer?: LoadStrikeDataTransferStats;
+    readonly Latency?: LoadStrikeLatencyStats;
+    readonly Request?: LoadStrikeRequestStats;
+    readonly StatusCodes?: LoadStrikeStatusCodeStats[];
+}
+export interface LoadStrikeLoadSimulationStats {
+    simulationName: string;
+    value: number;
+    readonly SimulationName?: string;
+    readonly Value?: number;
+}
+export interface LoadStrikeThresholdResult {
+    scenarioName: string;
+    scope: "scenario" | "step" | "metric";
+    stepName: string;
+    checkExpression: string;
+    isFailed: boolean;
+    errorCount: number;
+    exceptionMessage?: string;
+    readonly ScenarioName?: string;
+    readonly Scope?: "scenario" | "step" | "metric";
+    readonly StepName?: string;
+    readonly CheckExpression?: string;
+    readonly IsFailed?: boolean;
+    readonly ErrorCount?: number;
+    readonly ExceptionMessage?: string;
+}
+export declare class LoadStrikePluginDataTable {
+    tableName: string;
+    headers: string[];
+    rows: Array<Record<string, unknown>>;
+    constructor(tableName: string, headers?: string[], rows?: Array<Record<string, unknown>>);
+    static create(tableName: string): LoadStrikePluginDataTable;
+    static Create(tableName: string): LoadStrikePluginDataTable;
+    get TableName(): string;
+    get Headers(): string[];
+    get Rows(): Array<Record<string, unknown>>;
+}
+export declare class LoadStrikePluginData {
+    pluginName: string;
+    hints: string[];
+    tables: LoadStrikePluginDataTable[];
+    constructor(pluginName: string, tables?: LoadStrikePluginDataTable[], hints?: string[]);
+    static create(pluginName: string): LoadStrikePluginData;
+    static Create(pluginName: string): LoadStrikePluginData;
+    get PluginName(): string;
+    get Hints(): string[];
+    get Tables(): LoadStrikePluginDataTable[];
+}
+export declare class LoadStrikeReportData {
+    scenarioStats: LoadStrikeScenarioStats[];
+    constructor(scenarioStats?: LoadStrikeScenarioStats[]);
+    static create(...scenarioStats: LoadStrikeScenarioStats[]): LoadStrikeReportData;
+    static Create(...scenarioStats: LoadStrikeScenarioStats[]): LoadStrikeReportData;
+    static fromRunResult(result: LoadStrikeRunResult): LoadStrikeReportData;
+    findScenarioStats(scenarioName: string): LoadStrikeScenarioStats | undefined;
+    getScenarioStats(scenarioName: string): LoadStrikeScenarioStats;
+    FindScenarioStats(scenarioName: string): LoadStrikeScenarioStats | undefined;
+    GetScenarioStats(scenarioName: string): LoadStrikeScenarioStats;
+    get ScenarioStats(): LoadStrikeScenarioStats[];
+}
+export interface LoadStrikeRunResult {
+    startedUtc: string;
+    completedUtc: string;
+    allRequestCount: number;
+    allOkCount: number;
+    allFailCount: number;
+    failedThresholds: number;
+    nodeInfo: LoadStrikeNodeInfo;
+    testInfo: LoadStrikeTestInfo;
+    thresholdResults: LoadStrikeThresholdResult[];
+    metrics: LoadStrikeMetricValue[];
+    scenarioStats: LoadStrikeScenarioStats[];
+    stepStats: LoadStrikeStepStats[];
+    pluginsData: LoadStrikePluginData[];
+    disabledSinks: string[];
+    sinkErrors: LoadStrikeSinkError[];
+    reportFiles: string[];
+    readonly StartedUtc?: Date;
+    readonly CompletedUtc?: Date;
+    readonly AllRequestCount?: number;
+    readonly AllOkCount?: number;
+    readonly AllFailCount?: number;
+    readonly FailedThresholds?: number;
+    readonly NodeInfo?: LoadStrikeNodeInfo;
+    readonly TestInfo?: LoadStrikeTestInfo;
+    readonly ThresholdResults?: LoadStrikeThresholdResult[];
+    readonly Metrics?: LoadStrikeMetricValue[];
+    readonly ScenarioStats?: LoadStrikeScenarioStats[];
+    readonly StepStats?: LoadStrikeStepStats[];
+    readonly PluginsData?: LoadStrikePluginData[];
+    readonly DisabledSinks?: string[];
+    readonly SinkErrors?: LoadStrikeSinkError[];
+    readonly ReportFiles?: string[];
+}
+export interface LoadStrikeStepStats extends LoadStrikeStepRuntime {
+    ok: LoadStrikeMeasurementStats;
+    fail: LoadStrikeMeasurementStats;
+    sortIndex: number;
+    readonly ScenarioName?: string;
+    readonly StepName?: string;
+    readonly OkCount?: number;
+    readonly FailCount?: number;
+    readonly RequestCount?: number;
+    readonly TotalBytes?: number;
+    readonly TotalLatencyMs?: number;
+    readonly AvgLatencyMs?: number;
+    readonly MinLatencyMs?: number;
+    readonly MaxLatencyMs?: number;
+    readonly StatusCodes?: Record<string, number>;
+    readonly Ok?: LoadStrikeMeasurementStats;
+    readonly Fail?: LoadStrikeMeasurementStats;
+    readonly SortIndex?: number;
+}
+export interface LoadStrikeScenarioStats extends LoadStrikeScenarioRuntime {
+    allBytes: number;
+    currentOperation: "None" | "Init" | "WarmUp" | "Bombing" | "Stop" | "Complete" | "Error";
+    durationMs: number;
+    ok: LoadStrikeMeasurementStats;
+    fail: LoadStrikeMeasurementStats;
+    loadSimulationStats: LoadStrikeLoadSimulationStats;
+    sortIndex: number;
+    stepStats: LoadStrikeStepStats[];
+    findStepStats: (stepName: string) => LoadStrikeStepStats | undefined;
+    getStepStats: (stepName: string) => LoadStrikeStepStats;
+    FindStepStats: (stepName: string) => LoadStrikeStepStats | undefined;
+    GetStepStats: (stepName: string) => LoadStrikeStepStats;
+    readonly ScenarioName?: string;
+    readonly AllBytes?: number;
+    readonly AllRequestCount?: number;
+    readonly AllOkCount?: number;
+    readonly AllFailCount?: number;
+    readonly TotalBytes?: number;
+    readonly TotalLatencyMs?: number;
+    readonly AvgLatencyMs?: number;
+    readonly MinLatencyMs?: number;
+    readonly MaxLatencyMs?: number;
+    readonly StatusCodes?: Record<string, number>;
+    readonly CurrentOperation?: "None" | "Init" | "WarmUp" | "Bombing" | "Stop" | "Complete" | "Error";
+    readonly DurationMs?: number;
+    readonly Duration?: number;
+    readonly Ok?: LoadStrikeMeasurementStats;
+    readonly Fail?: LoadStrikeMeasurementStats;
+    readonly LoadSimulationStats?: LoadStrikeLoadSimulationStats;
+    readonly SortIndex?: number;
+    readonly StepStats?: LoadStrikeStepStats[];
+}
+export interface LoadStrikeNodeStats {
+    startedUtc: string;
+    completedUtc: string;
+    allBytes: number;
+    allRequestCount: number;
+    allOkCount: number;
+    allFailCount: number;
+    failedThresholds: number;
+    durationMs: number;
+    nodeInfo: LoadStrikeNodeInfo;
+    testInfo: LoadStrikeTestInfo;
+    thresholds: LoadStrikeThresholdResult[];
+    thresholdResults: LoadStrikeThresholdResult[];
+    metrics: LoadStrikeMetricStats;
+    metricValues: LoadStrikeMetricValue[];
+    scenarioStats: LoadStrikeScenarioStats[];
+    stepStats: LoadStrikeStepStats[];
+    pluginsData: LoadStrikePluginData[];
+    disabledSinks: string[];
+    sinkErrors: LoadStrikeSinkError[];
+    reportFiles: string[];
+    findScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
+    getScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats;
+    FindScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats | undefined;
+    GetScenarioStats: (scenarioName: string) => LoadStrikeScenarioStats;
+    readonly StartedUtc?: Date;
+    readonly CompletedUtc?: Date;
+    readonly AllBytes?: number;
+    readonly AllRequestCount?: number;
+    readonly AllOkCount?: number;
+    readonly AllFailCount?: number;
+    readonly FailedThresholds?: number;
+    readonly DurationMs?: number;
+    readonly Duration?: number;
+    readonly NodeInfo?: LoadStrikeNodeInfo;
+    readonly TestInfo?: LoadStrikeTestInfo;
+    readonly Thresholds?: LoadStrikeThresholdResult[];
+    readonly ThresholdResults?: LoadStrikeThresholdResult[];
+    readonly Metrics?: LoadStrikeMetricStats;
+    readonly MetricValues?: LoadStrikeMetricValue[];
+    readonly ScenarioStats?: LoadStrikeScenarioStats[];
+    readonly StepStats?: LoadStrikeStepStats[];
+    readonly PluginsData?: LoadStrikePluginData[];
+    readonly DisabledSinks?: string[];
+    readonly SinkErrors?: LoadStrikeSinkError[];
+    readonly ReportFiles?: string[];
+}
+export interface LoadStrikeSinkError {
+    sinkName: string;
+    phase: "init" | "start" | "realtime" | "final" | "run-result" | "stop";
+    message: string;
+    attempts: number;
+    readonly SinkName?: string;
+    readonly Phase?: "init" | "start" | "realtime" | "final" | "stop";
+    readonly Message?: string;
+    readonly Attempts?: number;
+}
+export interface LoadStrikeSinkSession {
+    startedUtc: string;
+    scenarioNames: string[];
+    scenarios: LoadStrikeScenarioStartInfo[];
+    logger: LoadStrikeLogger;
+    nodeInfo: LoadStrikeNodeInfo;
+    testInfo: LoadStrikeTestInfo;
+    configPath?: string;
+    infraConfigPath?: string;
+    infraConfig?: Record<string, unknown>;
+}
+export interface LoadStrikeBaseContext {
+    logger: LoadStrikeLogger;
+    nodeInfo: LoadStrikeNodeInfo;
+    testInfo: LoadStrikeTestInfo;
+    getNodeInfo: () => LoadStrikeNodeInfo;
+    readonly Logger?: LoadStrikeLogger;
+    readonly NodeInfo?: LoadStrikeNodeInfo;
+    readonly TestInfo?: LoadStrikeTestInfo;
+    GetNodeInfo?: () => LoadStrikeNodeInfo;
+}
+export interface LoadStrikeSessionStartInfo extends LoadStrikeBaseContext {
+    startedUtc: string;
+    scenarioNames: string[];
+    scenarios: LoadStrikeScenarioStartInfo[];
+    readonly StartedUtc?: string;
+    readonly ScenarioNames?: string[];
+    readonly Scenarios?: LoadStrikeScenarioStartInfo[];
+}
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Omit<T, Keys> & {
+    [Key in Keys]-?: Required<Pick<T, Key>> & Partial<Pick<T, Exclude<Keys, Key>>>;
+}[Keys];
+export interface LoadStrikeReportingSink {
+    sinkName?: string;
+    SinkName?: string;
+    init?: (context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>) => Promise<void> | void;
+    Init?: (context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>) => Promise<void> | void;
+    start?: (session: LoadStrikeSessionStartInfo) => Promise<void> | void;
+    Start?: (session: LoadStrikeSessionStartInfo) => Promise<void> | void;
+    saveRealtimeStats?: (scenarioStats: LoadStrikeScenarioStats[]) => Promise<void> | void;
+    SaveRealtimeStats?: (scenarioStats: LoadStrikeScenarioStats[]) => Promise<void> | void;
+    saveRealtimeMetrics?: (metrics: LoadStrikeMetricStats) => Promise<void> | void;
+    SaveRealtimeMetrics?: (metrics: LoadStrikeMetricStats) => Promise<void> | void;
+    saveFinalStats?: (result: LoadStrikeNodeStats) => Promise<void> | void;
+    SaveFinalStats?: (result: LoadStrikeNodeStats) => Promise<void> | void;
+    saveRunResult?: (result: LoadStrikeRunResult) => Promise<void> | void;
+    SaveRunResult?: (result: LoadStrikeRunResult) => Promise<void> | void;
+    stop?: () => Promise<void> | void;
+    Stop?: () => Promise<void> | void;
+    dispose?: () => Promise<void> | void;
+    Dispose?: () => Promise<void> | void;
+}
+export type ILoadStrikeReportingSink = RequireAtLeastOne<LoadStrikeReportingSink, "sinkName" | "SinkName">;
+export interface LoadStrikeRuntimePolicy {
+    shouldRunScenario?: (scenarioName: string) => boolean | Promise<boolean>;
+    beforeScenario?: (scenarioName: string) => Promise<void> | void;
+    afterScenario?: (scenarioName: string, stats: LoadStrikeScenarioRuntime) => Promise<void> | void;
+    beforeStep?: (scenarioName: string, stepName: string) => Promise<void> | void;
+    afterStep?: (scenarioName: string, stepName: string, reply: LoadStrikeStepReply) => Promise<void> | void;
+}
+export interface LoadStrikeWorkerPlugin {
+    pluginName?: string;
+    PluginName?: string;
+    init?: (context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>) => Promise<void> | void;
+    Init?: (context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>) => Promise<void> | void;
+    start?: (session: LoadStrikeSessionStartInfo) => Promise<void> | void;
+    Start?: (session: LoadStrikeSessionStartInfo) => Promise<void> | void;
+    stop?: () => Promise<void> | void;
+    Stop?: () => Promise<void> | void;
+    dispose?: () => Promise<void> | void;
+    Dispose?: () => Promise<void> | void;
+    getData?: (result: LoadStrikeNodeStats) => Promise<LoadStrikePluginData | null> | LoadStrikePluginData | null;
+    GetData?: (result: LoadStrikeNodeStats) => Promise<LoadStrikePluginData | null> | LoadStrikePluginData | null;
+}
+export type ILoadStrikeWorkerPlugin = RequireAtLeastOne<LoadStrikeWorkerPlugin, "pluginName" | "PluginName">;
+export interface LoadStrikeRunnerOptions {
+    displayConsoleMetrics?: boolean;
+    nodeType?: LoadStrikeNodeTypeInput;
+    localDevClusterEnabled?: boolean;
+    agentGroup?: string;
+    agentsCount?: number;
+    targetScenarios?: string[];
+    agentTargetScenarios?: string[];
+    coordinatorTargetScenarios?: string[];
+    natsServerUrl?: string;
+    runnerKey?: string;
+    licenseValidationServerUrl?: string;
+    licenseValidationTimeoutSeconds?: number;
+    configPath?: string;
+    infraConfigPath?: string;
+    infraConfig?: Record<string, unknown>;
+    clusterId?: string;
+    sessionId?: string;
+    testSuite?: string;
+    testName?: string;
+    reportsEnabled?: boolean;
+    reportFolderPath?: string;
+    reportFileName?: string;
+    reportFormats?: Array<LoadStrikeReportFormat>;
+    reportFinalizer?: (reportData: LoadStrikeReportData) => LoadStrikeReportData;
+    detailedReportFinalizer?: (result: LoadStrikeRunResult) => LoadStrikeRunResult;
+    reportingIntervalSeconds?: number;
+    minimumLogLevel?: LoadStrikeLogLevel | string;
+    loggerConfig?: () => LoadStrikeLogger;
+    reportingSinks?: ILoadStrikeReportingSink[];
+    sinkRetryCount?: number;
+    sinkRetryBackoffMs?: number;
+    scenarioCompletionTimeoutSeconds?: number;
+    clusterCommandTimeoutSeconds?: number;
+    restartIterationMaxAttempts?: number;
+    customSettings?: Record<string, unknown>;
+    globalCustomSettings?: Record<string, unknown>;
+    runtimePolicies?: LoadStrikeRuntimePolicy[];
+    workerPlugins?: ILoadStrikeWorkerPlugin[];
+    runArgs?: string[];
+}
+export interface LoadStrikeThresholdOptions {
+    abortWhenErrorCount?: number;
+    startCheckAfterSeconds?: number;
+}
+export interface LoadStrikeThresholdPredicateContext {
+    scenarioName: string;
+    scope: "scenario" | "step" | "metric";
+    stepName: string;
+    checkExpression: string;
+    scenarioStats: LoadStrikeScenarioRuntime;
+    stepStats: LoadStrikeStepRuntime[];
+    runStats: {
+        allRequestCount: number;
+        allOkCount: number;
+        allFailCount: number;
+        durationMs: number;
+    };
+    metrics: Record<string, number>;
+}
+type LoadStrikeThresholdPredicate = (context: LoadStrikeThresholdPredicateContext) => boolean | Promise<boolean>;
+export interface LoadStrikeScenarioPartition {
+    number: number;
+    count: number;
+    readonly Number?: number;
+    readonly Count?: number;
+}
+export interface LoadStrikeNodeInfo {
+    machineName: string;
+    nodeType: LoadStrikeNodeType;
+    engineVersion: string;
+    coresCount: number;
+    currentOperation: LoadStrikeOperationType;
+    dotNetVersion: string;
+    os: string;
+    processor: string;
+    readonly MachineName?: string;
+    readonly NodeType?: LoadStrikeNodeType;
+    readonly EngineVersion?: string;
+    readonly CoresCount?: number;
+    readonly CurrentOperation?: LoadStrikeOperationType;
+    readonly DotNetVersion?: string;
+    readonly OS?: string;
+    readonly Processor?: string;
+}
+export interface LoadStrikeTestInfo {
+    clusterId: string;
+    sessionId: string;
+    testSuite: string;
+    testName: string;
+    createdUtc: string;
+    readonly ClusterId?: string;
+    readonly SessionId?: string;
+    readonly TestSuite?: string;
+    readonly TestName?: string;
+    readonly CreatedUtc?: Date;
+    readonly Created?: Date;
+}
+export interface LoadStrikeScenarioInfo {
+    scenarioName: string;
+    instanceId: string;
+    instanceNumber: number;
+    scenarioOperation: "Init" | "Clean" | "WarmUp" | "Bombing";
+    scenarioDurationMs: number;
+    readonly ScenarioName?: string;
+    readonly InstanceId?: string;
+    readonly InstanceNumber?: number;
+    readonly ScenarioOperation?: "Init" | "Clean" | "WarmUp" | "Bombing";
+    readonly ScenarioDurationMs?: number;
+    readonly ScenarioDuration?: number;
+}
+export interface LoadStrikeScenarioStartInfo {
+    scenarioName: string;
+    sortIndex: number;
+    readonly ScenarioName?: string;
+    readonly SortIndex?: number;
+}
+export interface LoadStrikeLogger {
+    debug: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}
+export interface LoadStrikeScenarioInitContext {
+    customSettings: Record<string, unknown>;
+    globalCustomSettings: Record<string, unknown>;
+    logger: LoadStrikeLogger;
+    nodeInfo: LoadStrikeNodeInfo;
+    testInfo: LoadStrikeTestInfo;
+    scenarioInfo: LoadStrikeScenarioInfo;
+    scenarioPartition: LoadStrikeScenarioPartition;
+    registerMetric: (metric: unknown) => void;
+    registeredMetrics: unknown[];
+    readonly CustomSettings?: Record<string, unknown>;
+    readonly GlobalCustomSettings?: Record<string, unknown>;
+    readonly Logger?: LoadStrikeLogger;
+    readonly NodeInfo?: LoadStrikeNodeInfo;
+    readonly TestInfo?: LoadStrikeTestInfo;
+    readonly ScenarioInfo?: LoadStrikeScenarioInfo;
+    readonly ScenarioPartition?: LoadStrikeScenarioPartition;
+    RegisterMetric?: (metric: unknown) => void;
+    readonly RegisteredMetrics?: unknown[];
+}
+export interface LoadStrikeScenarioContext {
+    data: Record<string, unknown>;
+    scenarioInstanceData: Record<string, unknown>;
+    invocationNumber: number;
+    logger: LoadStrikeLogger;
+    nodeInfo: LoadStrikeNodeInfo;
+    random: LoadStrikeRandom;
+    testInfo: LoadStrikeTestInfo;
+    scenarioInfo: LoadStrikeScenarioInfo;
+    scenarioCancellationToken: AbortSignal;
+    getScenarioTimerTime: () => number;
+    stopScenario: (scenarioNameOrReason?: string, reason?: string) => void;
+    stopCurrentTest: (reason?: string) => void;
+    readonly Data?: Record<string, unknown>;
+    readonly ScenarioInstanceData?: Record<string, unknown>;
+    readonly InvocationNumber?: number;
+    readonly Logger?: LoadStrikeLogger;
+    readonly NodeInfo?: LoadStrikeNodeInfo;
+    readonly Random?: LoadStrikeRandom;
+    readonly TestInfo?: LoadStrikeTestInfo;
+    readonly ScenarioInfo?: LoadStrikeScenarioInfo;
+    readonly ScenarioCancellationToken?: AbortSignal;
+    GetScenarioTimerTime?: () => number;
+    StopScenario?: (scenarioNameOrReason?: string, reason?: string) => void;
+    StopCurrentTest?: (reason?: string) => void;
+}
+export declare class LoadStrikeResponse {
+    static ok(statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply;
+    static ok<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
+    static Ok(statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply;
+    static Ok<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
+    static okWithPayload<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
+    static OkWithPayload<TPayload>(payload: TPayload, statusCode?: string, sizeBytesOrMessage?: number | string, messageOrSizeBytes?: string | number, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
+    static fail(statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply;
+    static fail<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
+    static Fail(statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply;
+    static Fail<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
+    static failWithPayload<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
+    static FailWithPayload<TPayload>(payload: TPayload, statusCode?: string, messageOrSizeBytes?: string | number, sizeBytesOrMessage?: number | string, customLatencyMs?: number): LoadStrikeStepReply<TPayload>;
+}
+export declare class LoadStrikeStep {
+    static run<TPayload = unknown>(stepName: string, context: LoadStrikeScenarioContext, run: () => Promise<LoadStrikeStepReply<TPayload>> | LoadStrikeStepReply<TPayload>): Promise<LoadStrikeStepReply<TPayload>>;
+    static Run<TPayload = unknown>(stepName: string, context: LoadStrikeScenarioContext, run: () => Promise<LoadStrikeStepReply<TPayload>> | LoadStrikeStepReply<TPayload>): Promise<LoadStrikeStepReply<TPayload>>;
+}
+export declare class LoadStrikeSimulation {
+    static inject(rate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    static Inject(rate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    static iterationsForConstant(copies: number, iterations: number): Record<string, unknown>;
+    static IterationsForConstant(copies: number, iterations: number): Record<string, unknown>;
+    static iterationsForInject(rate: number, intervalSeconds: number, iterations: number): Record<string, unknown>;
+    static IterationsForInject(rate: number, intervalSeconds: number, iterations: number): Record<string, unknown>;
+    static keepConstant(copies: number, duringSeconds: number): Record<string, unknown>;
+    static KeepConstant(copies: number, duringSeconds: number): Record<string, unknown>;
+    static injectRandom(minRate: number, maxRate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    static InjectRandom(minRate: number, maxRate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    static rampingInject(rate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    static RampingInject(rate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    static rampingConstant(copies: number, duringSeconds: number): Record<string, unknown>;
+    static RampingConstant(copies: number, duringSeconds: number): Record<string, unknown>;
+    static pause(duringSeconds: number): Record<string, unknown>;
+    static Pause(duringSeconds: number): Record<string, unknown>;
+}
+export declare class LoadStrikeCounter {
+    readonly type: "counter";
+    readonly name: string;
+    readonly unitOfMeasure: string;
+    private current;
+    constructor(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string);
+    add(value: number): number;
+    increment(by?: number): number;
+    value(): number;
+    Add(value: number): number;
+    Increment(by?: number): number;
+    get MetricName(): string;
+    get UnitOfMeasure(): string;
+    get Value(): number;
+}
+export declare class LoadStrikeGauge {
+    readonly type: "gauge";
+    readonly name: string;
+    readonly unitOfMeasure: string;
+    private current;
+    constructor(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string);
+    set(value: number): number;
+    add(value: number): number;
+    increment(by?: number): number;
+    decrement(by?: number): number;
+    value(): number;
+    Set(value: number): number;
+    Add(value: number): number;
+    Increment(by?: number): number;
+    Decrement(by?: number): number;
+    get MetricName(): string;
+    get UnitOfMeasure(): string;
+    get Value(): number;
+}
+export declare class LoadStrikeMetric {
+    static counter(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string): LoadStrikeCounter;
+    static gauge(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string): LoadStrikeGauge;
+    static Counter(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string): LoadStrikeCounter;
+    static Gauge(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string): LoadStrikeGauge;
+    static CreateCounter(name: string, unitOfMeasure?: string): LoadStrikeCounter;
+    static CreateGauge(name: string, unitOfMeasure?: string): LoadStrikeGauge;
+}
+export declare class LoadStrikeThreshold {
+    static scenario(field: string, operator: string, value: number, options?: LoadStrikeThresholdOptions): Record<string, unknown>;
+    static step(stepName: string, field: string, operator: string, value: number, options?: LoadStrikeThresholdOptions): Record<string, unknown>;
+    static metric(field: string, operator: string, value: number, options?: LoadStrikeThresholdOptions): Record<string, unknown>;
+    static scenarioPredicate(checkExpression: string, predicate: LoadStrikeThresholdPredicate, options?: LoadStrikeThresholdOptions): Record<string, unknown>;
+    static stepPredicate(stepName: string, checkExpression: string, predicate: LoadStrikeThresholdPredicate, options?: LoadStrikeThresholdOptions): Record<string, unknown>;
+    static metricPredicate(checkExpression: string, predicate: LoadStrikeThresholdPredicate, options?: LoadStrikeThresholdOptions): Record<string, unknown>;
+    static CreateScenario(predicate: LoadStrikeThresholdPredicate, options?: LoadStrikeThresholdOptions): Record<string, unknown>;
+    static CreateScenario(predicate: LoadStrikeThresholdPredicate, abortWhenErrorCount?: number, startCheckAfterSeconds?: number): Record<string, unknown>;
+    static CreateStep(stepName: string, predicate: LoadStrikeThresholdPredicate, options?: LoadStrikeThresholdOptions): Record<string, unknown>;
+    static CreateStep(stepName: string, predicate: LoadStrikeThresholdPredicate, abortWhenErrorCount?: number, startCheckAfterSeconds?: number): Record<string, unknown>;
+    static CreateMetric(predicate: LoadStrikeThresholdPredicate, options?: LoadStrikeThresholdOptions): Record<string, unknown>;
+    static CreateMetric(predicate: LoadStrikeThresholdPredicate, abortWhenErrorCount?: number, startCheckAfterSeconds?: number): Record<string, unknown>;
+}
+export declare class CrossPlatformScenarioConfigurator {
+    static configure(scenario: LoadStrikeScenario, configuration: Record<string, unknown>): LoadStrikeScenario;
+    static Configure(scenario: LoadStrikeScenario, configuration: Record<string, unknown>): LoadStrikeScenario;
+}
+export declare class ScenarioTrackingExtensions {
+    static ConfigureCrossPlatformTracking(scenario: LoadStrikeScenario, configuration: Record<string, unknown>): LoadStrikeScenario;
+    static WithCrossPlatformTracking(scenario: LoadStrikeScenario, configuration: Record<string, unknown>): LoadStrikeScenario;
+}
+export interface LoadStrikeRunContext {
+    ConsoleMetricsEnabled?: boolean;
+    LocalDevClusterEnabled?: boolean;
+    ConfigPath?: string;
+    InfraConfigPath?: string;
+    InfraConfig?: Record<string, unknown>;
+    AgentGroup?: string;
+    AgentsCount?: number;
+    AgentTargetScenarios?: string[];
+    ClusterId?: string;
+    CoordinatorTargetScenarios?: string[];
+    RunnerKey?: string;
+    LicenseValidationServerUrl?: string;
+    LicenseValidationTimeoutSeconds?: number;
+    MinimumLogLevel?: LoadStrikeLogLevel | string;
+    LoggerConfig?: () => LoadStrikeLogger;
+    NatsServerUrl?: string;
+    NodeType?: LoadStrikeNodeTypeInput;
+    ReportsEnabled?: boolean;
+    ReportFileName?: string;
+    ReportFolderPath?: string;
+    ReportFormats?: LoadStrikeReportFormat[];
+    ReportFinalizer?: (reportData: LoadStrikeReportData) => LoadStrikeReportData;
+    DetailedReportFinalizer?: (result: LoadStrikeRunResult) => LoadStrikeRunResult;
+    ReportingIntervalSeconds?: number;
+    ReportingSinks?: ILoadStrikeReportingSink[];
+    SinkRetryCount?: number;
+    SinkRetryBackoffMs?: number;
+    RuntimePolicies?: LoadStrikeRuntimePolicy[];
+    ScenarioCompletionTimeoutSeconds?: number;
+    ClusterCommandTimeoutSeconds?: number;
+    RestartIterationMaxAttempts?: number;
+    SessionId?: string;
+    TargetScenarios?: string[];
+    TestName?: string;
+    TestSuite?: string;
+    WorkerPlugins?: ILoadStrikeWorkerPlugin[];
+    CustomSettings?: Record<string, unknown>;
+    GlobalCustomSettings?: Record<string, unknown>;
+}
+export declare class LoadStrikeContext {
+    private values;
+    private registeredScenarios;
+    private runArgs;
+    constructor(values?: LoadStrikeRunContext, registeredScenarios?: LoadStrikeScenario[], runArgs?: string[]);
+    static create(): LoadStrikeContext;
+    toObject(): LoadStrikeRunContext;
+    buildContext(): LoadStrikeContext;
+    BuildContext(): LoadStrikeContext;
+    run(): Promise<LoadStrikeNodeStats>;
+    run(args: string[]): Promise<LoadStrikeNodeStats>;
+    run(...args: string[]): Promise<LoadStrikeNodeStats>;
+    runDetailed(): Promise<LoadStrikeRunResult>;
+    runDetailed(args: string[]): Promise<LoadStrikeRunResult>;
+    runDetailed(...args: string[]): Promise<LoadStrikeRunResult>;
+    Run(): Promise<LoadStrikeNodeStats>;
+    Run(args: string[]): Promise<LoadStrikeNodeStats>;
+    Run(...args: string[]): Promise<LoadStrikeNodeStats>;
+    RunDetailed(): Promise<LoadStrikeRunResult>;
+    RunDetailed(args: string[]): Promise<LoadStrikeRunResult>;
+    RunDetailed(...args: string[]): Promise<LoadStrikeRunResult>;
+    toRunnerOptions(): LoadStrikeRunnerOptions;
+    configure(configure: (context: LoadStrikeContext) => LoadStrikeContext): LoadStrikeContext;
+    configure(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeContext;
+    configure(options: LoadStrikeRunnerOptions): LoadStrikeContext;
+    Configure(configure: (context: LoadStrikeContext) => LoadStrikeContext): LoadStrikeContext;
+    Configure(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeContext;
+    Configure(options: LoadStrikeRunnerOptions): LoadStrikeContext;
+    configureContext(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeContext;
+    ConfigureContext(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeContext;
+    buildLicenseValidationPayload(): LoadStrikeRunRequest;
+    BuildLicenseValidationPayload(): LoadStrikeRunRequest;
+    displayConsoleMetrics(enable: boolean): LoadStrikeContext;
+    DisplayConsoleMetrics(enable: boolean): LoadStrikeContext;
+    enableLocalDevCluster(enable: boolean): LoadStrikeContext;
+    EnableLocalDevCluster(enable: boolean): LoadStrikeContext;
+    loadConfig(path: string): LoadStrikeContext;
+    LoadConfig(path: string): LoadStrikeContext;
+    loadInfraConfig(path: string): LoadStrikeContext;
+    LoadInfraConfig(path: string): LoadStrikeContext;
+    withAgentGroup(agentGroup: string): LoadStrikeContext;
+    WithAgentGroup(agentGroup: string): LoadStrikeContext;
+    withAgentsCount(agentsCount: number): LoadStrikeContext;
+    WithAgentsCount(agentsCount: number): LoadStrikeContext;
+    withTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    WithTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    withAgentTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    WithAgentTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    withCoordinatorTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    WithCoordinatorTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    withRunnerKey(runnerKey: string): LoadStrikeContext;
+    WithRunnerKey(runnerKey: string): LoadStrikeContext;
+    withLicenseValidationServerUrl(serverUrl: string): LoadStrikeContext;
+    WithLicenseValidationServerUrl(serverUrl: string): LoadStrikeContext;
+    withLicenseValidationTimeout(timeoutSeconds: number): LoadStrikeContext;
+    WithLicenseValidationTimeout(timeoutSeconds: number): LoadStrikeContext;
+    withNodeType(nodeType: LoadStrikeNodeTypeInput): LoadStrikeContext;
+    WithNodeType(nodeType: LoadStrikeNodeTypeInput): LoadStrikeContext;
+    withNatsServerUrl(natsUrl: string): LoadStrikeContext;
+    WithNatsServerUrl(natsUrl: string): LoadStrikeContext;
+    withoutReports(): LoadStrikeContext;
+    WithoutReports(): LoadStrikeContext;
+    withReportFileName(reportFileName: string): LoadStrikeContext;
+    WithReportFileName(reportFileName: string): LoadStrikeContext;
+    withReportFolder(reportFolderPath: string): LoadStrikeContext;
+    WithReportFolder(reportFolderPath: string): LoadStrikeContext;
+    withReportFormats(...reportFormats: Array<LoadStrikeReportFormat | string>): LoadStrikeContext;
+    WithReportFormats(...reportFormats: Array<LoadStrikeReportFormat | string>): LoadStrikeContext;
+    withReportFinalizer(handler: (reportData: LoadStrikeReportData) => LoadStrikeReportData): LoadStrikeContext;
+    WithReportFinalizer(handler: (reportData: LoadStrikeReportData) => LoadStrikeReportData): LoadStrikeContext;
+    withDetailedReportFinalizer(handler: (result: LoadStrikeRunResult) => LoadStrikeRunResult): LoadStrikeContext;
+    WithDetailedReportFinalizer(handler: (result: LoadStrikeRunResult) => LoadStrikeRunResult): LoadStrikeContext;
+    withReportingInterval(intervalSeconds: number): LoadStrikeContext;
+    WithReportingInterval(intervalSeconds: number): LoadStrikeContext;
+    withReportingSinks(...sinks: ILoadStrikeReportingSink[]): LoadStrikeContext;
+    WithReportingSinks(...sinks: ILoadStrikeReportingSink[]): LoadStrikeContext;
+    withWorkerPlugins(...plugins: ILoadStrikeWorkerPlugin[]): LoadStrikeContext;
+    WithWorkerPlugins(...plugins: ILoadStrikeWorkerPlugin[]): LoadStrikeContext;
+    withMinimumLogLevel(minimumLogLevel: LoadStrikeLogLevel | string): LoadStrikeContext;
+    WithMinimumLogLevel(minimumLogLevel: LoadStrikeLogLevel | string): LoadStrikeContext;
+    withLoggerConfig(loggerConfig: () => LoadStrikeLogger): LoadStrikeContext;
+    WithLoggerConfig(loggerConfig: () => LoadStrikeLogger): LoadStrikeContext;
+    withScenarioCompletionTimeout(timeoutSeconds: number): LoadStrikeContext;
+    WithScenarioCompletionTimeout(timeoutSeconds: number): LoadStrikeContext;
+    withClusterCommandTimeout(timeoutSeconds: number): LoadStrikeContext;
+    WithClusterCommandTimeout(timeoutSeconds: number): LoadStrikeContext;
+    withRestartIterationMaxAttempts(attempts: number): LoadStrikeContext;
+    WithRestartIterationMaxAttempts(attempts: number): LoadStrikeContext;
+    withSessionId(sessionId: string): LoadStrikeContext;
+    WithSessionId(sessionId: string): LoadStrikeContext;
+    withTestSuite(testSuite: string): LoadStrikeContext;
+    WithTestSuite(testSuite: string): LoadStrikeContext;
+    withTestName(testName: string): LoadStrikeContext;
+    WithTestName(testName: string): LoadStrikeContext;
+    withClusterId(clusterId: string): LoadStrikeContext;
+    WithClusterId(clusterId: string): LoadStrikeContext;
+    private mergeValues;
+    private assignState;
+    withRegisteredScenarios(...scenarios: LoadStrikeScenario[]): LoadStrikeContext;
+}
+export declare class LoadStrikeScenario {
+    readonly name: string;
+    private readonly runHandler;
+    private readonly initHandler?;
+    private readonly cleanHandler?;
+    private readonly loadSimulations;
+    private readonly thresholds;
+    private readonly trackingConfiguration?;
+    private readonly maxFailCount;
+    private readonly withoutWarmUpValue;
+    private readonly warmUpDurationSeconds;
+    private readonly weight;
+    private readonly restartIterationOnFail;
+    private readonly licenseFeatures;
+    private constructor();
+    static create(name: string, runHandler: (context: LoadStrikeScenarioContext) => Promise<LoadStrikeStepReply> | LoadStrikeStepReply): LoadStrikeScenario;
+    static Create(name: string, runHandler: (context: LoadStrikeScenarioContext) => Promise<LoadStrikeStepReply> | LoadStrikeStepReply): LoadStrikeScenario;
+    static empty(name: string): LoadStrikeScenario;
+    static Empty(name: string): LoadStrikeScenario;
+    get Name(): string;
+    withInit(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    withClean(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    withMaxFailCount(maxFailCount: number): LoadStrikeScenario;
+    withoutWarmUp(): LoadStrikeScenario;
+    withWarmUpDuration(durationSeconds: number): LoadStrikeScenario;
+    withWeight(weight: number): LoadStrikeScenario;
+    withRestartIterationOnFail(shouldRestart: boolean): LoadStrikeScenario;
+    withCrossPlatformTracking(configuration: Record<string, unknown>): LoadStrikeScenario;
+    withLoadSimulations(...simulations: Array<Record<string, unknown>>): LoadStrikeScenario;
+    withThresholds(...thresholds: Array<Record<string, unknown>>): LoadStrikeScenario;
+    withLicenseFeatures(...features: string[]): LoadStrikeScenario;
+    getSimulations(): Array<Record<string, unknown>>;
+    getThresholds(): Array<Record<string, unknown>>;
+    getTrackingConfiguration(): Record<string, unknown> | undefined;
+    getMaxFailCount(): number;
+    isWithoutWarmUp(): boolean;
+    getWarmUpDurationSeconds(): number;
+    getWeight(): number;
+    shouldRestartIterationOnFail(): boolean;
+    getLicenseFeatures(): string[];
+    invokeInit(context: LoadStrikeScenarioInitContext): Promise<void>;
+    invokeClean(context: LoadStrikeScenarioInitContext): Promise<void>;
+    execute(context: LoadStrikeScenarioContext): Promise<LoadStrikeStepReply>;
+    WithCrossPlatformTracking(configuration: Record<string, unknown>): LoadStrikeScenario;
+    WithInit(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    WithClean(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    WithLoadSimulations(...simulations: Array<Record<string, unknown>>): LoadStrikeScenario;
+    WithMaxFailCount(maxFailCount: number): LoadStrikeScenario;
+    WithoutWarmUp(): LoadStrikeScenario;
+    WithRestartIterationOnFail(shouldRestart: boolean): LoadStrikeScenario;
+    WithLicenseFeatures(...features: string[]): LoadStrikeScenario;
+    WithThresholds(...thresholds: Array<Record<string, unknown>>): LoadStrikeScenario;
+    WithWarmUpDuration(durationSeconds: number): LoadStrikeScenario;
+    WithWeight(weight: number): LoadStrikeScenario;
+}
+export declare class LoadStrikeRunner {
+    private scenarios;
+    private options;
+    private contextConfigurators;
+    private constructor();
+    static create(): LoadStrikeRunner;
+    static Create(): LoadStrikeRunner;
+    static registerScenarios(...scenarios: LoadStrikeScenario[]): LoadStrikeContext;
+    static RegisterScenarios(...scenarios: LoadStrikeScenario[]): LoadStrikeContext;
+    static DisplayConsoleMetrics(context: LoadStrikeContext, enable: boolean): LoadStrikeContext;
+    static EnableLocalDevCluster(context: LoadStrikeContext, enable: boolean): LoadStrikeContext;
+    static LoadConfig(context: LoadStrikeContext, path: string): LoadStrikeContext;
+    static LoadInfraConfig(context: LoadStrikeContext, path: string): LoadStrikeContext;
+    static Run(context: LoadStrikeContext, ...args: string[]): Promise<LoadStrikeNodeStats>;
+    static WithAgentGroup(context: LoadStrikeContext, agentGroup: string): LoadStrikeContext;
+    static WithAgentsCount(context: LoadStrikeContext, agentsCount: number): LoadStrikeContext;
+    static WithAgentTargetScenarios(context: LoadStrikeContext, ...scenarioNames: string[]): LoadStrikeContext;
+    static WithClusterId(context: LoadStrikeContext, clusterId: string): LoadStrikeContext;
+    static WithCoordinatorTargetScenarios(context: LoadStrikeContext, ...scenarioNames: string[]): LoadStrikeContext;
+    static WithRunnerKey(context: LoadStrikeContext, runnerKey: string): LoadStrikeContext;
+    static WithLicenseValidationServerUrl(context: LoadStrikeContext, serverUrl: string): LoadStrikeContext;
+    static WithLicenseValidationTimeout(context: LoadStrikeContext, timeoutSeconds: number): LoadStrikeContext;
+    static WithLoggerConfig(context: LoadStrikeContext, loggerConfig: () => LoadStrikeLogger): LoadStrikeContext;
+    static WithMinimumLogLevel(context: LoadStrikeContext, minimumLogLevel: LoadStrikeLogLevel | string): LoadStrikeContext;
+    static WithNatsServerUrl(context: LoadStrikeContext, natsUrl: string): LoadStrikeContext;
+    static WithNodeType(context: LoadStrikeContext, nodeType: LoadStrikeNodeTypeInput): LoadStrikeContext;
+    static WithoutReports(context: LoadStrikeContext): LoadStrikeContext;
+    static WithReportFileName(context: LoadStrikeContext, reportFileName: string): LoadStrikeContext;
+    static WithReportFinalizer(context: LoadStrikeContext, handler: (reportData: LoadStrikeReportData) => LoadStrikeReportData): LoadStrikeContext;
+    static WithDetailedReportFinalizer(context: LoadStrikeContext, handler: (result: LoadStrikeRunResult) => LoadStrikeRunResult): LoadStrikeContext;
+    static WithReportFolder(context: LoadStrikeContext, reportFolderPath: string): LoadStrikeContext;
+    static WithReportFormats(context: LoadStrikeContext, ...reportFormats: Array<LoadStrikeReportFormat | string>): LoadStrikeContext;
+    static WithReportingInterval(context: LoadStrikeContext, intervalSeconds: number): LoadStrikeContext;
+    static WithReportingSinks(context: LoadStrikeContext, ...sinks: ILoadStrikeReportingSink[]): LoadStrikeContext;
+    static WithScenarioCompletionTimeout(context: LoadStrikeContext, timeoutSeconds: number): LoadStrikeContext;
+    static WithClusterCommandTimeout(context: LoadStrikeContext, timeoutSeconds: number): LoadStrikeContext;
+    static WithRestartIterationMaxAttempts(context: LoadStrikeContext, attempts: number): LoadStrikeContext;
+    static WithSessionId(context: LoadStrikeContext, sessionId: string): LoadStrikeContext;
+    static WithTargetScenarios(context: LoadStrikeContext, ...scenarioNames: string[]): LoadStrikeContext;
+    static WithTestName(context: LoadStrikeContext, testName: string): LoadStrikeContext;
+    static WithTestSuite(context: LoadStrikeContext, testSuite: string): LoadStrikeContext;
+    static WithWorkerPlugins(context: LoadStrikeContext, ...plugins: ILoadStrikeWorkerPlugin[]): LoadStrikeContext;
+    addScenario(scenario: LoadStrikeScenario): LoadStrikeRunner;
+    AddScenario(scenario: LoadStrikeScenario): LoadStrikeRunner;
+    addScenarios(...scenarios: LoadStrikeScenario[]): LoadStrikeRunner;
+    AddScenarios(...scenarios: LoadStrikeScenario[]): LoadStrikeRunner;
+    configure(options: LoadStrikeRunnerOptions): LoadStrikeRunner;
+    Configure(configure: (context: LoadStrikeContext) => LoadStrikeContext): LoadStrikeRunner;
+    Configure(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeRunner;
+    Configure(options: LoadStrikeRunnerOptions): LoadStrikeRunner;
+    configureContext(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeRunner;
+    ConfigureContext(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeRunner;
+    withTestSuite(testSuite: string): LoadStrikeRunner;
+    WithTestSuite(testSuite: string): LoadStrikeRunner;
+    withTestName(testName: string): LoadStrikeRunner;
+    WithTestName(testName: string): LoadStrikeRunner;
+    withSessionId(sessionId: string): LoadStrikeRunner;
+    WithSessionId(sessionId: string): LoadStrikeRunner;
+    withReportFolder(reportFolderPath: string): LoadStrikeRunner;
+    WithReportFolder(reportFolderPath: string): LoadStrikeRunner;
+    withReportingInterval(intervalSeconds: number): LoadStrikeRunner;
+    WithReportingInterval(intervalSeconds: number): LoadStrikeRunner;
+    withClusterCommandTimeout(timeoutSeconds: number): LoadStrikeRunner;
+    WithClusterCommandTimeout(timeoutSeconds: number): LoadStrikeRunner;
+    withRestartIterationMaxAttempts(attempts: number): LoadStrikeRunner;
+    WithRestartIterationMaxAttempts(attempts: number): LoadStrikeRunner;
+    withoutReports(): LoadStrikeRunner;
+    WithoutReports(): LoadStrikeRunner;
+    buildContext(): LoadStrikeContext;
+    BuildContext(): LoadStrikeContext;
+    run(args?: string[]): Promise<LoadStrikeNodeStats>;
+    runDetailed(args?: string[]): Promise<LoadStrikeRunResult>;
+    Run(args?: string[]): Promise<LoadStrikeNodeStats>;
+    RunDetailed(args?: string[]): Promise<LoadStrikeRunResult>;
+    private filterScenariosWithPolicies;
+    private runClusterChildNode;
+    private runCoordinatorWithLocalAgents;
+    private runCoordinatorWithNats;
+    private runAgentWithNats;
+    private stopPlugins;
+    private executeScenarioInvocation;
+    private selectScenarios;
+    private buildLicenseValidationPayload;
+    private initializeSinks;
+    private startSinks;
+    private emitRealtimeStats;
+    private emitFinalStats;
+    private stopSinks;
+    private emitRunResult;
+    private invokeSinkAction;
+    private invokeBeforeScenario;
+    private invokeAfterScenario;
+    private writeReports;
+    private collectPluginData;
+}
+export {};