@loadstrike/loadstrike-sdk 1.0.20801 → 1.0.21101

package/dist/types/runtime.d.ts

@@ -244,8 +244,20 @@ export declare class LoadStrikePluginDataTable {
     tableName: string;
     headers: string[];
     rows: Array<Record<string, unknown>>;
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(tableName: string, headers?: string[], rows?: Array<Record<string, unknown>>);
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static create(tableName: string): LoadStrikePluginDataTable;
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static Create(tableName: string): LoadStrikePluginDataTable;
     get TableName(): string;
     get Headers(): string[];
@@ -255,8 +267,20 @@ export declare class LoadStrikePluginData {
     pluginName: string;
     hints: string[];
     tables: LoadStrikePluginDataTable[];
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(pluginName: string, tables?: LoadStrikePluginDataTable[], hints?: string[]);
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static create(pluginName: string): LoadStrikePluginData;
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static Create(pluginName: string): LoadStrikePluginData;
     get PluginName(): string;
     get Hints(): string[];
@@ -427,7 +451,15 @@ declare class MeasurementAccumulator {
     private readonly sizesBytes;
     private readonly statusCodes;
     get Count(): number;
+    /**
+     * Exposes the public record operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     record(reply: LoadStrikeStepReply, observedLatencyMs: number): void;
+    /**
+     * Builds the configured payload or helper object.
+     * Use this when all builder inputs are ready to be materialized.
+     */
     build(allRequestCount: number, durationMs: number): LoadStrikeMeasurementStats;
 }
 declare class StepStatsAccumulator {
@@ -437,7 +469,15 @@ declare class StepStatsAccumulator {
     readonly ok: MeasurementAccumulator;
     readonly fail: MeasurementAccumulator;
     constructor(scenarioName: string, stepName: string, sortIndex: number);
+    /**
+     * Exposes the public record operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     record(reply: LoadStrikeStepReply, observedLatencyMs: number): void;
+    /**
+     * Builds the configured payload or helper object.
+     * Use this when all builder inputs are ready to be materialized.
+     */
     build(allScenarioRequestCount: number, durationMs: number): LoadStrikeStepStats;
 }
 declare class ScenarioStatsAccumulator {
@@ -450,11 +490,35 @@ declare class ScenarioStatsAccumulator {
     private loadSimulationStats;
     private currentOperation;
     constructor(scenarioName: string, sortIndex: number);
+    /**
+     * Exposes the public setLoadSimulation operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     setLoadSimulation(simulationName: string, value: number): void;
+    /**
+     * Exposes the public setCurrentOperation operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     setCurrentOperation(operation: LoadStrikeScenarioStats["currentOperation"]): void;
+    /**
+     * Returns current operation.
+     * Use this when current operation is required for branching, logging, or assertions.
+     */
     getCurrentOperation(): LoadStrikeScenarioStats["currentOperation"];
+    /**
+     * Exposes the public recordScenario operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     recordScenario(reply: LoadStrikeStepReply, observedLatencyMs: number): void;
+    /**
+     * Exposes the public recordStep operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     recordStep(stepName: string, reply: LoadStrikeStepReply, observedLatencyMs: number): void;
+    /**
+     * Builds the configured payload or helper object.
+     * Use this when all builder inputs are ready to be materialized.
+     */
     build(durationMs: number): LoadStrikeScenarioStats;
 }
 export interface LoadStrikeSinkError {
@@ -593,6 +657,8 @@ export interface LoadStrikeRunnerOptions {
     runtimePolicies?: LoadStrikeRuntimePolicy[];
     workerPlugins?: ILoadStrikeWorkerPlugin[];
     runArgs?: string[];
+    agentExecutionToken?: string;
+    agentCommandId?: string;
 }
 export interface LoadStrikeThresholdOptions {
     abortWhenErrorCount?: number;
@@ -751,21 +817,85 @@ export declare class LoadStrikeStep {
     static RunAsync<TPayload = unknown>(stepName: string, context: LoadStrikeScenarioContext, run: () => Promise<LoadStrikeReply<TPayload>> | LoadStrikeReply<TPayload>): Promise<LoadStrikeReply<TPayload>>;
 }
 export declare class LoadStrikeSimulation {
+    /**
+     * Builds a constant injection load shape.
+     * Use this when requests should be injected at a fixed rate over a duration.
+     */
     static inject(rate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    /**
+     * Builds a constant injection load shape.
+     * Use this when requests should be injected at a fixed rate over a duration.
+     */
     static Inject(rate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    /**
+     * Builds an iteration-limited constant-concurrency load shape.
+     * Use this when a fixed number of iterations should be shared across constant workers.
+     */
     static iterationsForConstant(copies: number, iterations: number): Record<string, unknown>;
+    /**
+     * Builds an iteration-limited constant-concurrency load shape.
+     * Use this when a fixed number of iterations should be shared across constant workers.
+     */
     static IterationsForConstant(copies: number, iterations: number): Record<string, unknown>;
+    /**
+     * Builds an iteration-limited injection load shape.
+     * Use this when a fixed number of injected iterations should be executed.
+     */
     static iterationsForInject(rate: number, intervalSeconds: number, iterations: number): Record<string, unknown>;
+    /**
+     * Builds an iteration-limited injection load shape.
+     * Use this when a fixed number of injected iterations should be executed.
+     */
     static IterationsForInject(rate: number, intervalSeconds: number, iterations: number): Record<string, unknown>;
+    /**
+     * Builds a constant-concurrency load shape.
+     * Use this when a fixed number of virtual users should stay active.
+     */
     static keepConstant(copies: number, duringSeconds: number): Record<string, unknown>;
+    /**
+     * Builds a constant-concurrency load shape.
+     * Use this when a fixed number of virtual users should stay active.
+     */
     static KeepConstant(copies: number, duringSeconds: number): Record<string, unknown>;
+    /**
+     * Builds a randomized injection load shape.
+     * Use this when traffic should fluctuate between a minimum and maximum rate.
+     */
     static injectRandom(minRate: number, maxRate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    /**
+     * Builds a randomized injection load shape.
+     * Use this when traffic should fluctuate between a minimum and maximum rate.
+     */
     static InjectRandom(minRate: number, maxRate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    /**
+     * Builds a ramping injection load shape.
+     * Use this when request rate should increase over time.
+     */
     static rampingInject(rate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    /**
+     * Builds a ramping injection load shape.
+     * Use this when request rate should increase over time.
+     */
     static RampingInject(rate: number, intervalSeconds: number, duringSeconds: number): Record<string, unknown>;
+    /**
+     * Builds a ramping-concurrency load shape.
+     * Use this when the number of active virtual users should climb over time.
+     */
     static rampingConstant(copies: number, duringSeconds: number): Record<string, unknown>;
+    /**
+     * Builds a ramping-concurrency load shape.
+     * Use this when the number of active virtual users should climb over time.
+     */
     static RampingConstant(copies: number, duringSeconds: number): Record<string, unknown>;
+    /**
+     * Builds a pause segment in a load profile.
+     * Use this when a simulation should intentionally idle for a period.
+     */
     static pause(duringSeconds: number): Record<string, unknown>;
+    /**
+     * Builds a pause segment in a load profile.
+     * Use this when a simulation should intentionally idle for a period.
+     */
     static Pause(duringSeconds: number): Record<string, unknown>;
 }
 export declare class LoadStrikeCounter {
@@ -773,11 +903,35 @@ export declare class LoadStrikeCounter {
     readonly name: string;
     readonly unitOfMeasure: string;
     private current;
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string);
+    /**
+     * Adds a value to the current metric.
+     * Use this when a counter or gauge should be incremented by an explicit delta.
+     */
     add(value: number): number;
+    /**
+     * Increments the current metric by one.
+     * Use this when events should simply be counted.
+     */
     increment(by?: number): number;
+    /**
+     * Returns the current metric value.
+     * Use this when custom metric state needs to be inspected inside user code.
+     */
     value(): number;
+    /**
+     * Adds a value to the current metric.
+     * Use this when a counter or gauge should be incremented by an explicit delta.
+     */
     Add(value: number): number;
+    /**
+     * Increments the current metric by one.
+     * Use this when events should simply be counted.
+     */
     Increment(by?: number): number;
     get MetricName(): string;
     get UnitOfMeasure(): string;
@@ -788,26 +942,90 @@ export declare class LoadStrikeGauge {
     readonly name: string;
     readonly unitOfMeasure: string;
     private current;
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string);
+    /**
+     * Sets the current gauge value.
+     * Use this when the latest observed value should replace the previous one.
+     */
     set(value: number): number;
+    /**
+     * Adds a value to the current metric.
+     * Use this when a counter or gauge should be incremented by an explicit delta.
+     */
     add(value: number): number;
+    /**
+     * Increments the current metric by one.
+     * Use this when events should simply be counted.
+     */
     increment(by?: number): number;
+    /**
+     * Decrements the current metric by one.
+     * Use this when a gauge should move down by a single unit.
+     */
     decrement(by?: number): number;
+    /**
+     * Returns the current metric value.
+     * Use this when custom metric state needs to be inspected inside user code.
+     */
     value(): number;
+    /**
+     * Sets the current gauge value.
+     * Use this when the latest observed value should replace the previous one.
+     */
     Set(value: number): number;
+    /**
+     * Adds a value to the current metric.
+     * Use this when a counter or gauge should be incremented by an explicit delta.
+     */
     Add(value: number): number;
+    /**
+     * Increments the current metric by one.
+     * Use this when events should simply be counted.
+     */
     Increment(by?: number): number;
+    /**
+     * Decrements the current metric by one.
+     * Use this when a gauge should move down by a single unit.
+     */
     Decrement(by?: number): number;
     get MetricName(): string;
     get UnitOfMeasure(): string;
     get Value(): number;
 }
 export declare class LoadStrikeMetric {
+    /**
+     * Creates a counter metric.
+     * Use this when a scenario should accumulate a monotonically increasing custom metric.
+     */
     static counter(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string): LoadStrikeCounter;
+    /**
+     * Creates a gauge metric.
+     * Use this when a scenario should track the latest value of a custom metric.
+     */
     static gauge(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string): LoadStrikeGauge;
+    /**
+     * Creates a counter metric.
+     * Use this when a scenario should accumulate a monotonically increasing custom metric.
+     */
     static Counter(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string): LoadStrikeCounter;
+    /**
+     * Creates a gauge metric.
+     * Use this when a scenario should track the latest value of a custom metric.
+     */
     static Gauge(name: string, initialValueOrUnit?: number | string, unitOfMeasure?: string): LoadStrikeGauge;
+    /**
+     * Creates a counter metric.
+     * Use this when a scenario should accumulate a monotonically increasing custom metric.
+     */
     static CreateCounter(name: string, unitOfMeasure?: string): LoadStrikeCounter;
+    /**
+     * Creates a gauge metric.
+     * Use this when a scenario should track the latest value of a custom metric.
+     */
     static CreateGauge(name: string, unitOfMeasure?: string): LoadStrikeGauge;
 }
 export declare class LoadStrikeThreshold {
@@ -872,15 +1090,33 @@ export interface LoadStrikeRunContext {
     WorkerPlugins?: ILoadStrikeWorkerPlugin[];
     CustomSettings?: Record<string, unknown>;
     GlobalCustomSettings?: Record<string, unknown>;
+    AgentExecutionToken?: string;
+    AgentCommandId?: string;
 }
 export declare class LoadStrikeContext {
     private values;
     private registeredScenarios;
     private runArgs;
     constructor(values?: LoadStrikeRunContext, registeredScenarios?: LoadStrikeScenario[], runArgs?: string[]);
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static create(): LoadStrikeContext;
+    /**
+     * Exposes the public toObject operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     toObject(): LoadStrikeRunContext;
+    /**
+     * Builds the current configuration into a runnable context.
+     * Use this when you want to inspect or reuse the final run settings before execution.
+     */
     buildContext(): LoadStrikeContext;
+    /**
+     * Builds the current configuration into a runnable context.
+     * Use this when you want to inspect or reuse the final run settings before execution.
+     */
     BuildContext(): LoadStrikeContext;
     run(): Promise<LoadStrikeRunResult>;
     run(args: string[]): Promise<LoadStrikeRunResult>;
@@ -888,6 +1124,10 @@ export declare class LoadStrikeContext {
     Run(): Promise<LoadStrikeRunResult>;
     Run(args: string[]): Promise<LoadStrikeRunResult>;
     Run(...args: string[]): Promise<LoadStrikeRunResult>;
+    /**
+     * Exposes the public toRunnerOptions operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     toRunnerOptions(): LoadStrikeRunnerOptions;
     configure(configure: (context: LoadStrikeContext) => LoadStrikeContext): LoadStrikeContext;
     configure(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeContext;
@@ -895,72 +1135,332 @@ export declare class LoadStrikeContext {
     Configure(configure: (context: LoadStrikeContext) => LoadStrikeContext): LoadStrikeContext;
     Configure(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeContext;
     Configure(options: LoadStrikeRunnerOptions): LoadStrikeContext;
+    /**
+     * Copies settings from an existing context snapshot.
+     * Use this when a runner should inherit configuration that was already assembled elsewhere.
+     */
     configureContext(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeContext;
+    /**
+     * Copies settings from an existing context snapshot.
+     * Use this when a runner should inherit configuration that was already assembled elsewhere.
+     */
     ConfigureContext(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeContext;
+    /**
+     * Toggles realtime console metric output.
+     * Use this when a local run or CI log should stream live throughput and latency updates.
+     */
     displayConsoleMetrics(enable: boolean): LoadStrikeContext;
+    /**
+     * Toggles realtime console metric output.
+     * Use this when a local run or CI log should stream live throughput and latency updates.
+     */
     DisplayConsoleMetrics(enable: boolean): LoadStrikeContext;
+    /**
+     * Toggles local development cluster mode.
+     * Use this when you want to simulate coordinator and agent behavior on a single machine.
+     */
     enableLocalDevCluster(enable: boolean): LoadStrikeContext;
+    /**
+     * Toggles local development cluster mode.
+     * Use this when you want to simulate coordinator and agent behavior on a single machine.
+     */
     EnableLocalDevCluster(enable: boolean): LoadStrikeContext;
+    /**
+     * Loads run settings from a JSON config file.
+     * Use this when configuration should come from a checked-in or generated config document.
+     */
     loadConfig(path: string): LoadStrikeContext;
+    /**
+     * Loads run settings from a JSON config file.
+     * Use this when configuration should come from a checked-in or generated config document.
+     */
     LoadConfig(path: string): LoadStrikeContext;
+    /**
+     * Loads infrastructure settings for sinks, plugins, or transport dependencies.
+     * Use this when runtime integrations depend on external connection details.
+     */
     loadInfraConfig(path: string): LoadStrikeContext;
+    /**
+     * Loads infrastructure settings for sinks, plugins, or transport dependencies.
+     * Use this when runtime integrations depend on external connection details.
+     */
     LoadInfraConfig(path: string): LoadStrikeContext;
+    /**
+     * Sets the agent group for this node or run.
+     * Use this when only a subset of agents should pick up a particular workload.
+     */
     withAgentGroup(agentGroup: string): LoadStrikeContext;
+    /**
+     * Sets the agent group for this node or run.
+     * Use this when only a subset of agents should pick up a particular workload.
+     */
     WithAgentGroup(agentGroup: string): LoadStrikeContext;
+    /**
+     * Sets the requested agent count.
+     * Use this when a coordinator should fan work out across a specific number of agents.
+     */
     withAgentsCount(agentsCount: number): LoadStrikeContext;
+    /**
+     * Sets the requested agent count.
+     * Use this when a coordinator should fan work out across a specific number of agents.
+     */
     WithAgentsCount(agentsCount: number): LoadStrikeContext;
+    /**
+     * Targets a shared set of scenarios.
+     * Use this when only selected scenarios should execute for the current node or run.
+     */
     withTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    /**
+     * Targets a shared set of scenarios.
+     * Use this when only selected scenarios should execute for the current node or run.
+     */
     WithTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    /**
+     * Targets scenarios for agent nodes only.
+     * Use this when agents should execute only a subset of the registered scenarios.
+     */
     withAgentTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    /**
+     * Targets scenarios for agent nodes only.
+     * Use this when agents should execute only a subset of the registered scenarios.
+     */
     WithAgentTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    /**
+     * Targets scenarios for the coordinator only.
+     * Use this when orchestration or control-node work should run on the coordinator itself.
+     */
     withCoordinatorTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    /**
+     * Targets scenarios for the coordinator only.
+     * Use this when orchestration or control-node work should run on the coordinator itself.
+     */
     WithCoordinatorTargetScenarios(...scenarioNames: string[]): LoadStrikeContext;
+    /**
+     * Sets the runner key used for licensing validation.
+     * Use this when the run must authenticate against the licensing API before it starts.
+     */
     withRunnerKey(runnerKey: string): LoadStrikeContext;
+    /**
+     * Sets the runner key used for licensing validation.
+     * Use this when the run must authenticate against the licensing API before it starts.
+     */
     WithRunnerKey(runnerKey: string): LoadStrikeContext;
+    /**
+     * Sets how long the SDK waits for licensing validation to complete.
+     * Use this when control-plane latency or private networking requires a longer validation window.
+     */
     withLicenseValidationTimeout(timeoutSeconds: number): LoadStrikeContext;
+    /**
+     * Sets how long the SDK waits for licensing validation to complete.
+     * Use this when control-plane latency or private networking requires a longer validation window.
+     */
     WithLicenseValidationTimeout(timeoutSeconds: number): LoadStrikeContext;
+    /**
+     * Sets the runtime node type.
+     * Use this when a process should behave as a single node, coordinator, or agent.
+     */
     withNodeType(nodeType: LoadStrikeNodeTypeInput): LoadStrikeContext;
+    /**
+     * Sets the runtime node type.
+     * Use this when a process should behave as a single node, coordinator, or agent.
+     */
     WithNodeType(nodeType: LoadStrikeNodeTypeInput): LoadStrikeContext;
+    /**
+     * Sets the NATS server URL used for distributed cluster coordination.
+     * Use this when coordinator and agent nodes communicate over NATS.
+     */
     withNatsServerUrl(natsUrl: string): LoadStrikeContext;
+    /**
+     * Sets the NATS server URL used for distributed cluster coordination.
+     * Use this when coordinator and agent nodes communicate over NATS.
+     */
     WithNatsServerUrl(natsUrl: string): LoadStrikeContext;
+    /**
+     * Disables local report generation.
+     * Use this when reports are unnecessary or should be handled exclusively by sinks.
+     */
     withoutReports(): LoadStrikeContext;
+    /**
+     * Disables local report generation.
+     * Use this when reports are unnecessary or should be handled exclusively by sinks.
+     */
     WithoutReports(): LoadStrikeContext;
+    /**
+     * Sets the base file name for generated reports.
+     * Use this when exported reports should use a predictable naming convention.
+     */
     withReportFileName(reportFileName: string): LoadStrikeContext;
+    /**
+     * Sets the base file name for generated reports.
+     * Use this when exported reports should use a predictable naming convention.
+     */
     WithReportFileName(reportFileName: string): LoadStrikeContext;
+    /**
+     * Sets the output folder for generated reports.
+     * Use this when report files should land in a specific directory.
+     */
     withReportFolder(reportFolderPath: string): LoadStrikeContext;
+    /**
+     * Sets the output folder for generated reports.
+     * Use this when report files should land in a specific directory.
+     */
     WithReportFolder(reportFolderPath: string): LoadStrikeContext;
+    /**
+     * Restricts generated reports to specific formats.
+     * Use this when you want only selected report artifacts such as HTML, CSV, or Markdown.
+     */
     withReportFormats(...reportFormats: Array<LoadStrikeReportFormat | string>): LoadStrikeContext;
+    /**
+     * Restricts generated reports to specific formats.
+     * Use this when you want only selected report artifacts such as HTML, CSV, or Markdown.
+     */
     WithReportFormats(...reportFormats: Array<LoadStrikeReportFormat | string>): LoadStrikeContext;
+    /**
+     * Sets the realtime reporting cadence.
+     * Use this when sinks or dashboards should receive updates at a controlled interval.
+     */
     withReportingInterval(intervalSeconds: number): LoadStrikeContext;
+    /**
+     * Sets the realtime reporting cadence.
+     * Use this when sinks or dashboards should receive updates at a controlled interval.
+     */
     WithReportingInterval(intervalSeconds: number): LoadStrikeContext;
+    /**
+     * Registers one or more reporting sinks.
+     * Use this when run results must be pushed to external observability or storage systems.
+     */
     withReportingSinks(...sinks: ILoadStrikeReportingSink[]): LoadStrikeContext;
+    /**
+     * Registers one or more reporting sinks.
+     * Use this when run results must be pushed to external observability or storage systems.
+     */
     WithReportingSinks(...sinks: ILoadStrikeReportingSink[]): LoadStrikeContext;
+    /**
+     * Registers runtime policies for the run.
+     * Use this when scenario selection or step execution should obey policy callbacks.
+     */
     withRuntimePolicies(...policies: LoadStrikeRuntimePolicy[]): LoadStrikeContext;
+    /**
+     * Registers runtime policies for the run.
+     * Use this when scenario selection or step execution should obey policy callbacks.
+     */
     WithRuntimePolicies(...policies: LoadStrikeRuntimePolicy[]): LoadStrikeContext;
+    /**
+     * Sets how runtime policy failures are handled.
+     * Use this when policy errors should either fail fast or be tolerated.
+     */
     withRuntimePolicyErrorMode(mode: LoadStrikeRuntimePolicyErrorMode | string): LoadStrikeContext;
+    /**
+     * Sets how runtime policy failures are handled.
+     * Use this when policy errors should either fail fast or be tolerated.
+     */
     WithRuntimePolicyErrorMode(mode: LoadStrikeRuntimePolicyErrorMode | string): LoadStrikeContext;
+    /**
+     * Registers worker plugins for the run.
+     * Use this when custom plugin data should be collected alongside run results.
+     */
     withWorkerPlugins(...plugins: ILoadStrikeWorkerPlugin[]): LoadStrikeContext;
+    /**
+     * Registers worker plugins for the run.
+     * Use this when custom plugin data should be collected alongside run results.
+     */
     WithWorkerPlugins(...plugins: ILoadStrikeWorkerPlugin[]): LoadStrikeContext;
+    /**
+     * Sets the minimum runtime log level.
+     * Use this when the run should emit less or more operational detail.
+     */
     withMinimumLogLevel(minimumLogLevel: LoadStrikeLogLevel | string): LoadStrikeContext;
+    /**
+     * Sets the minimum runtime log level.
+     * Use this when the run should emit less or more operational detail.
+     */
     WithMinimumLogLevel(minimumLogLevel: LoadStrikeLogLevel | string): LoadStrikeContext;
+    /**
+     * Supplies a custom logger configuration factory.
+     * Use this when the default runtime logging output is not enough for your environment.
+     */
     withLoggerConfig(loggerConfig: () => LoadStrikeLogger): LoadStrikeContext;
+    /**
+     * Supplies a custom logger configuration factory.
+     * Use this when the default runtime logging output is not enough for your environment.
+     */
     WithLoggerConfig(loggerConfig: () => LoadStrikeLogger): LoadStrikeContext;
+    /**
+     * Sets the timeout for scenario completion.
+     * Use this when long-running scenarios need an explicit completion window.
+     */
     withScenarioCompletionTimeout(timeoutSeconds: number): LoadStrikeContext;
+    /**
+     * Sets the timeout for scenario completion.
+     * Use this when long-running scenarios need an explicit completion window.
+     */
     WithScenarioCompletionTimeout(timeoutSeconds: number): LoadStrikeContext;
+    /**
+     * Sets the timeout for cluster command round-trips.
+     * Use this when distributed control messages need a tighter or looser deadline.
+     */
     withClusterCommandTimeout(timeoutSeconds: number): LoadStrikeContext;
+    /**
+     * Sets the timeout for cluster command round-trips.
+     * Use this when distributed control messages need a tighter or looser deadline.
+     */
     WithClusterCommandTimeout(timeoutSeconds: number): LoadStrikeContext;
+    /**
+     * Sets the retry limit for restartable failed iterations.
+     * Use this when transient failures should be retried a fixed number of times.
+     */
     withRestartIterationMaxAttempts(attempts: number): LoadStrikeContext;
+    /**
+     * Sets the retry limit for restartable failed iterations.
+     * Use this when transient failures should be retried a fixed number of times.
+     */
     WithRestartIterationMaxAttempts(attempts: number): LoadStrikeContext;
+    /**
+     * Sets the session identifier for this run.
+     * Use this when downstream logs, reports, or external systems need a stable session id.
+     */
     withSessionId(sessionId: string): LoadStrikeContext;
+    /**
+     * Sets the session identifier for this run.
+     * Use this when downstream logs, reports, or external systems need a stable session id.
+     */
     WithSessionId(sessionId: string): LoadStrikeContext;
+    /**
+     * Sets the test suite label for the run.
+     * Use this when related tests should be grouped under a suite name.
+     */
     withTestSuite(testSuite: string): LoadStrikeContext;
+    /**
+     * Sets the test suite label for the run.
+     * Use this when related tests should be grouped under a suite name.
+     */
     WithTestSuite(testSuite: string): LoadStrikeContext;
+    /**
+     * Sets the test name label for the run.
+     * Use this when reports and logs should expose a human-readable test identifier.
+     */
     withTestName(testName: string): LoadStrikeContext;
+    /**
+     * Sets the test name label for the run.
+     * Use this when reports and logs should expose a human-readable test identifier.
+     */
     WithTestName(testName: string): LoadStrikeContext;
+    /**
+     * Sets the cluster identifier for this run.
+     * Use this when multiple cluster nodes must join the same distributed execution.
+     */
     withClusterId(clusterId: string): LoadStrikeContext;
+    /**
+     * Sets the cluster identifier for this run.
+     * Use this when multiple cluster nodes must join the same distributed execution.
+     */
     WithClusterId(clusterId: string): LoadStrikeContext;
     private mergeValues;
     private assignState;
+    /**
+     * Configures registered scenarios for this SDK object.
+     * Use this when registered scenarios should be set explicitly before the run starts.
+     */
     withRegisteredScenarios(...scenarios: LoadStrikeScenario[]): LoadStrikeContext;
 }
 export declare class LoadStrikeScenario {
@@ -981,43 +1481,179 @@ export declare class LoadStrikeScenario {
     static Create(name: string, runHandler: (context: LoadStrikeScenarioContext) => Promise<LoadStrikeStepReply> | LoadStrikeStepReply): LoadStrikeScenario;
     static createAsync(name: string, runHandler: (context: LoadStrikeScenarioContext) => Promise<LoadStrikeStepReply> | LoadStrikeStepReply): LoadStrikeScenario;
     static CreateAsync(name: string, runHandler: (context: LoadStrikeScenarioContext) => Promise<LoadStrikeStepReply> | LoadStrikeStepReply): LoadStrikeScenario;
+    /**
+     * Creates a placeholder scenario that returns the default success reply.
+     * Use this when you want a scenario shell before adding setup, cleanup, or more detailed behavior.
+     */
     static empty(name: string): LoadStrikeScenario;
+    /**
+     * Creates a placeholder scenario that returns the default success reply.
+     * Use this when you want a scenario shell before adding setup, cleanup, or more detailed behavior.
+     */
     static Empty(name: string): LoadStrikeScenario;
     get Name(): string;
+    /**
+     * Configures init for this SDK object.
+     * Use this when init should be set explicitly before the run starts.
+     */
     withInit(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    /**
+     * Configures init async for this SDK object.
+     * Use this when init async should be set explicitly before the run starts.
+     */
     withInitAsync(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    /**
+     * Configures clean for this SDK object.
+     * Use this when clean should be set explicitly before the run starts.
+     */
     withClean(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    /**
+     * Configures clean async for this SDK object.
+     * Use this when clean async should be set explicitly before the run starts.
+     */
     withCleanAsync(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    /**
+     * Configures max fail count for this SDK object.
+     * Use this when max fail count should be set explicitly before the run starts.
+     */
     withMaxFailCount(maxFailCount: number): LoadStrikeScenario;
+    /**
+     * Configures out warm up for this SDK object.
+     * Use this when out warm up should be set explicitly before the run starts.
+     */
     withoutWarmUp(): LoadStrikeScenario;
+    /**
+     * Configures warm up duration for this SDK object.
+     * Use this when warm up duration should be set explicitly before the run starts.
+     */
     withWarmUpDuration(durationSeconds: number): LoadStrikeScenario;
+    /**
+     * Configures weight for this SDK object.
+     * Use this when weight should be set explicitly before the run starts.
+     */
     withWeight(weight: number): LoadStrikeScenario;
+    /**
+     * Configures restart iteration on fail for this SDK object.
+     * Use this when restart iteration on fail should be set explicitly before the run starts.
+     */
     withRestartIterationOnFail(shouldRestart: boolean): LoadStrikeScenario;
+    /**
+     * Configures cross platform tracking for this SDK object.
+     * Use this when cross platform tracking should be set explicitly before the run starts.
+     */
     withCrossPlatformTracking(configuration: Record<string, unknown>): LoadStrikeScenario;
+    /**
+     * Configures load simulations for this SDK object.
+     * Use this when load simulations should be set explicitly before the run starts.
+     */
     withLoadSimulations(...simulations: Array<Record<string, unknown>>): LoadStrikeScenario;
+    /**
+     * Configures thresholds for this SDK object.
+     * Use this when thresholds should be set explicitly before the run starts.
+     */
     withThresholds(...thresholds: Array<Record<string, unknown>>): LoadStrikeScenario;
+    /**
+     * Returns simulations.
+     * Use this when simulations is required for branching, logging, or assertions.
+     */
     getSimulations(): Array<Record<string, unknown>>;
+    /**
+     * Returns thresholds.
+     * Use this when thresholds is required for branching, logging, or assertions.
+     */
     getThresholds(): Array<Record<string, unknown>>;
+    /**
+     * Returns tracking configuration.
+     * Use this when tracking configuration is required for branching, logging, or assertions.
+     */
     getTrackingConfiguration(): Record<string, unknown> | undefined;
+    /**
+     * Returns max fail count.
+     * Use this when max fail count is required for branching, logging, or assertions.
+     */
     getMaxFailCount(): number;
+    /**
+     * Exposes the public isWithoutWarmUp operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     isWithoutWarmUp(): boolean;
+    /**
+     * Returns warm up duration seconds.
+     * Use this when warm up duration seconds is required for branching, logging, or assertions.
+     */
     getWarmUpDurationSeconds(): number;
+    /**
+     * Returns weight.
+     * Use this when weight is required for branching, logging, or assertions.
+     */
     getWeight(): number;
+    /**
+     * Exposes the public shouldRestartIterationOnFail operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     shouldRestartIterationOnFail(): boolean;
     invokeInit(context: LoadStrikeScenarioInitContext): Promise<void>;
     invokeClean(context: LoadStrikeScenarioInitContext): Promise<void>;
     execute(context: LoadStrikeScenarioContext): Promise<LoadStrikeStepReply>;
+    /**
+     * Configures cross platform tracking for this SDK object.
+     * Use this when cross platform tracking should be set explicitly before the run starts.
+     */
     WithCrossPlatformTracking(configuration: Record<string, unknown>): LoadStrikeScenario;
+    /**
+     * Configures init for this SDK object.
+     * Use this when init should be set explicitly before the run starts.
+     */
     WithInit(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    /**
+     * Configures init async for this SDK object.
+     * Use this when init async should be set explicitly before the run starts.
+     */
     WithInitAsync(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    /**
+     * Configures clean for this SDK object.
+     * Use this when clean should be set explicitly before the run starts.
+     */
     WithClean(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    /**
+     * Configures clean async for this SDK object.
+     * Use this when clean async should be set explicitly before the run starts.
+     */
     WithCleanAsync(handler: (context: LoadStrikeScenarioInitContext) => Promise<void> | void): LoadStrikeScenario;
+    /**
+     * Configures load simulations for this SDK object.
+     * Use this when load simulations should be set explicitly before the run starts.
+     */
     WithLoadSimulations(...simulations: Array<Record<string, unknown>>): LoadStrikeScenario;
+    /**
+     * Configures max fail count for this SDK object.
+     * Use this when max fail count should be set explicitly before the run starts.
+     */
     WithMaxFailCount(maxFailCount: number): LoadStrikeScenario;
+    /**
+     * Configures out warm up for this SDK object.
+     * Use this when out warm up should be set explicitly before the run starts.
+     */
     WithoutWarmUp(): LoadStrikeScenario;
+    /**
+     * Configures restart iteration on fail for this SDK object.
+     * Use this when restart iteration on fail should be set explicitly before the run starts.
+     */
     WithRestartIterationOnFail(shouldRestart: boolean): LoadStrikeScenario;
+    /**
+     * Configures thresholds for this SDK object.
+     * Use this when thresholds should be set explicitly before the run starts.
+     */
     WithThresholds(...thresholds: Array<Record<string, unknown>>): LoadStrikeScenario;
+    /**
+     * Configures warm up duration for this SDK object.
+     * Use this when warm up duration should be set explicitly before the run starts.
+     */
     WithWarmUpDuration(durationSeconds: number): LoadStrikeScenario;
+    /**
+     * Configures weight for this SDK object.
+     * Use this when weight should be set explicitly before the run starts.
+     */
     WithWeight(weight: number): LoadStrikeScenario;
 }
 export declare class LoadStrikeRunner {
@@ -1025,69 +1661,301 @@ export declare class LoadStrikeRunner {
     private options;
     private contextConfigurators;
     private constructor();
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static create(): LoadStrikeRunner;
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static Create(): LoadStrikeRunner;
+    /**
+     * Registers one or more scenarios on a fresh runnable context.
+     * Use this when you want a context immediately without composing a runner first.
+     */
     static registerScenarios(...scenarios: LoadStrikeScenario[]): LoadStrikeContext;
+    /**
+     * Registers one or more scenarios on a fresh runnable context.
+     * Use this when you want a context immediately without composing a runner first.
+     */
     static RegisterScenarios(...scenarios: LoadStrikeScenario[]): LoadStrikeContext;
+    /**
+     * Toggles realtime console metric output.
+     * Use this when a local run or CI log should stream live throughput and latency updates.
+     */
     static DisplayConsoleMetrics(context: LoadStrikeContext, enable: boolean): LoadStrikeContext;
+    /**
+     * Toggles local development cluster mode.
+     * Use this when you want to simulate coordinator and agent behavior on a single machine.
+     */
     static EnableLocalDevCluster(context: LoadStrikeContext, enable: boolean): LoadStrikeContext;
+    /**
+     * Loads run settings from a JSON config file.
+     * Use this when configuration should come from a checked-in or generated config document.
+     */
     static LoadConfig(context: LoadStrikeContext, path: string): LoadStrikeContext;
+    /**
+     * Loads infrastructure settings for sinks, plugins, or transport dependencies.
+     * Use this when runtime integrations depend on external connection details.
+     */
     static LoadInfraConfig(context: LoadStrikeContext, path: string): LoadStrikeContext;
+    /**
+     * Executes the configured workload through the SDK runtime.
+     * Use this when configuration is complete and you are ready to start the run.
+     */
     static Run(context: LoadStrikeContext, ...args: string[]): Promise<LoadStrikeRunResult>;
+    /**
+     * Sets the agent group for this node or run.
+     * Use this when only a subset of agents should pick up a particular workload.
+     */
     static WithAgentGroup(context: LoadStrikeContext, agentGroup: string): LoadStrikeContext;
+    /**
+     * Sets the requested agent count.
+     * Use this when a coordinator should fan work out across a specific number of agents.
+     */
     static WithAgentsCount(context: LoadStrikeContext, agentsCount: number): LoadStrikeContext;
+    /**
+     * Targets scenarios for agent nodes only.
+     * Use this when agents should execute only a subset of the registered scenarios.
+     */
     static WithAgentTargetScenarios(context: LoadStrikeContext, ...scenarioNames: string[]): LoadStrikeContext;
+    /**
+     * Sets the cluster identifier for this run.
+     * Use this when multiple cluster nodes must join the same distributed execution.
+     */
     static WithClusterId(context: LoadStrikeContext, clusterId: string): LoadStrikeContext;
+    /**
+     * Targets scenarios for the coordinator only.
+     * Use this when orchestration or control-node work should run on the coordinator itself.
+     */
     static WithCoordinatorTargetScenarios(context: LoadStrikeContext, ...scenarioNames: string[]): LoadStrikeContext;
+    /**
+     * Sets the runner key used for licensing validation.
+     * Use this when the run must authenticate against the licensing API before it starts.
+     */
     static WithRunnerKey(context: LoadStrikeContext, runnerKey: string): LoadStrikeContext;
+    /**
+     * Sets how long the SDK waits for licensing validation to complete.
+     * Use this when control-plane latency or private networking requires a longer validation window.
+     */
     static WithLicenseValidationTimeout(context: LoadStrikeContext, timeoutSeconds: number): LoadStrikeContext;
+    /**
+     * Supplies a custom logger configuration factory.
+     * Use this when the default runtime logging output is not enough for your environment.
+     */
     static WithLoggerConfig(context: LoadStrikeContext, loggerConfig: () => LoadStrikeLogger): LoadStrikeContext;
+    /**
+     * Sets the minimum runtime log level.
+     * Use this when the run should emit less or more operational detail.
+     */
     static WithMinimumLogLevel(context: LoadStrikeContext, minimumLogLevel: LoadStrikeLogLevel | string): LoadStrikeContext;
+    /**
+     * Sets the NATS server URL used for distributed cluster coordination.
+     * Use this when coordinator and agent nodes communicate over NATS.
+     */
     static WithNatsServerUrl(context: LoadStrikeContext, natsUrl: string): LoadStrikeContext;
     static WithNodeType(context: LoadStrikeContext, nodeType: LoadStrikeNodeTypeInput): LoadStrikeContext;
+    /**
+     * Disables local report generation.
+     * Use this when reports are unnecessary or should be handled exclusively by sinks.
+     */
     static WithoutReports(context: LoadStrikeContext): LoadStrikeContext;
+    /**
+     * Sets the base file name for generated reports.
+     * Use this when exported reports should use a predictable naming convention.
+     */
     static WithReportFileName(context: LoadStrikeContext, reportFileName: string): LoadStrikeContext;
+    /**
+     * Sets the output folder for generated reports.
+     * Use this when report files should land in a specific directory.
+     */
     static WithReportFolder(context: LoadStrikeContext, reportFolderPath: string): LoadStrikeContext;
     static WithReportFormats(context: LoadStrikeContext, ...reportFormats: Array<LoadStrikeReportFormat | string>): LoadStrikeContext;
+    /**
+     * Sets the realtime reporting cadence.
+     * Use this when sinks or dashboards should receive updates at a controlled interval.
+     */
     static WithReportingInterval(context: LoadStrikeContext, intervalSeconds: number): LoadStrikeContext;
+    /**
+     * Registers one or more reporting sinks.
+     * Use this when run results must be pushed to external observability or storage systems.
+     */
     static WithReportingSinks(context: LoadStrikeContext, ...sinks: ILoadStrikeReportingSink[]): LoadStrikeContext;
+    /**
+     * Registers runtime policies for the run.
+     * Use this when scenario selection or step execution should obey policy callbacks.
+     */
     static WithRuntimePolicies(context: LoadStrikeContext, ...policies: LoadStrikeRuntimePolicy[]): LoadStrikeContext;
     static WithRuntimePolicyErrorMode(context: LoadStrikeContext, mode: LoadStrikeRuntimePolicyErrorMode | string): LoadStrikeContext;
+    /**
+     * Sets the timeout for scenario completion.
+     * Use this when long-running scenarios need an explicit completion window.
+     */
     static WithScenarioCompletionTimeout(context: LoadStrikeContext, timeoutSeconds: number): LoadStrikeContext;
+    /**
+     * Sets the timeout for cluster command round-trips.
+     * Use this when distributed control messages need a tighter or looser deadline.
+     */
     static WithClusterCommandTimeout(context: LoadStrikeContext, timeoutSeconds: number): LoadStrikeContext;
+    /**
+     * Sets the retry limit for restartable failed iterations.
+     * Use this when transient failures should be retried a fixed number of times.
+     */
     static WithRestartIterationMaxAttempts(context: LoadStrikeContext, attempts: number): LoadStrikeContext;
+    /**
+     * Sets the session identifier for this run.
+     * Use this when downstream logs, reports, or external systems need a stable session id.
+     */
     static WithSessionId(context: LoadStrikeContext, sessionId: string): LoadStrikeContext;
+    /**
+     * Targets a shared set of scenarios.
+     * Use this when only selected scenarios should execute for the current node or run.
+     */
     static WithTargetScenarios(context: LoadStrikeContext, ...scenarioNames: string[]): LoadStrikeContext;
+    /**
+     * Sets the test name label for the run.
+     * Use this when reports and logs should expose a human-readable test identifier.
+     */
     static WithTestName(context: LoadStrikeContext, testName: string): LoadStrikeContext;
+    /**
+     * Sets the test suite label for the run.
+     * Use this when related tests should be grouped under a suite name.
+     */
     static WithTestSuite(context: LoadStrikeContext, testSuite: string): LoadStrikeContext;
+    /**
+     * Registers worker plugins for the run.
+     * Use this when custom plugin data should be collected alongside run results.
+     */
     static WithWorkerPlugins(context: LoadStrikeContext, ...plugins: ILoadStrikeWorkerPlugin[]): LoadStrikeContext;
+    /**
+     * Adds a scenario to the current runner.
+     * Use this when the run should include one more scenario definition.
+     */
     addScenario(scenario: LoadStrikeScenario): LoadStrikeRunner;
+    /**
+     * Adds a scenario to the current runner.
+     * Use this when the run should include one more scenario definition.
+     */
     AddScenario(scenario: LoadStrikeScenario): LoadStrikeRunner;
+    /**
+     * Adds multiple scenarios to the current runner.
+     * Use this when the run should execute a batch of scenario definitions together.
+     */
     addScenarios(...scenarios: LoadStrikeScenario[]): LoadStrikeRunner;
+    /**
+     * Adds multiple scenarios to the current runner.
+     * Use this when the run should execute a batch of scenario definitions together.
+     */
     AddScenarios(...scenarios: LoadStrikeScenario[]): LoadStrikeRunner;
+    /**
+     * Applies a grouped configuration change to the current builder or context.
+     * Use this when several related settings should be supplied in one step.
+     */
     configure(options: LoadStrikeRunnerOptions): LoadStrikeRunner;
     Configure(configure: (context: LoadStrikeContext) => LoadStrikeContext): LoadStrikeRunner;
     Configure(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeRunner;
     Configure(options: LoadStrikeRunnerOptions): LoadStrikeRunner;
+    /**
+     * Copies settings from an existing context snapshot.
+     * Use this when a runner should inherit configuration that was already assembled elsewhere.
+     */
     configureContext(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeRunner;
+    /**
+     * Copies settings from an existing context snapshot.
+     * Use this when a runner should inherit configuration that was already assembled elsewhere.
+     */
     ConfigureContext(context: LoadStrikeContext | LoadStrikeRunContext): LoadStrikeRunner;
+    /**
+     * Sets the test suite label for the run.
+     * Use this when related tests should be grouped under a suite name.
+     */
     withTestSuite(testSuite: string): LoadStrikeRunner;
+    /**
+     * Sets the test suite label for the run.
+     * Use this when related tests should be grouped under a suite name.
+     */
     WithTestSuite(testSuite: string): LoadStrikeRunner;
+    /**
+     * Sets the test name label for the run.
+     * Use this when reports and logs should expose a human-readable test identifier.
+     */
     withTestName(testName: string): LoadStrikeRunner;
+    /**
+     * Sets the test name label for the run.
+     * Use this when reports and logs should expose a human-readable test identifier.
+     */
     WithTestName(testName: string): LoadStrikeRunner;
+    /**
+     * Sets the session identifier for this run.
+     * Use this when downstream logs, reports, or external systems need a stable session id.
+     */
     withSessionId(sessionId: string): LoadStrikeRunner;
+    /**
+     * Sets the session identifier for this run.
+     * Use this when downstream logs, reports, or external systems need a stable session id.
+     */
     WithSessionId(sessionId: string): LoadStrikeRunner;
+    /**
+     * Sets the output folder for generated reports.
+     * Use this when report files should land in a specific directory.
+     */
     withReportFolder(reportFolderPath: string): LoadStrikeRunner;
+    /**
+     * Sets the output folder for generated reports.
+     * Use this when report files should land in a specific directory.
+     */
     WithReportFolder(reportFolderPath: string): LoadStrikeRunner;
+    /**
+     * Sets the realtime reporting cadence.
+     * Use this when sinks or dashboards should receive updates at a controlled interval.
+     */
     withReportingInterval(intervalSeconds: number): LoadStrikeRunner;
+    /**
+     * Sets the realtime reporting cadence.
+     * Use this when sinks or dashboards should receive updates at a controlled interval.
+     */
     WithReportingInterval(intervalSeconds: number): LoadStrikeRunner;
+    /**
+     * Sets the timeout for cluster command round-trips.
+     * Use this when distributed control messages need a tighter or looser deadline.
+     */
     withClusterCommandTimeout(timeoutSeconds: number): LoadStrikeRunner;
+    /**
+     * Sets the timeout for cluster command round-trips.
+     * Use this when distributed control messages need a tighter or looser deadline.
+     */
     WithClusterCommandTimeout(timeoutSeconds: number): LoadStrikeRunner;
+    /**
+     * Sets the retry limit for restartable failed iterations.
+     * Use this when transient failures should be retried a fixed number of times.
+     */
     withRestartIterationMaxAttempts(attempts: number): LoadStrikeRunner;
+    /**
+     * Sets the retry limit for restartable failed iterations.
+     * Use this when transient failures should be retried a fixed number of times.
+     */
     WithRestartIterationMaxAttempts(attempts: number): LoadStrikeRunner;
+    /**
+     * Disables local report generation.
+     * Use this when reports are unnecessary or should be handled exclusively by sinks.
+     */
     withoutReports(): LoadStrikeRunner;
+    /**
+     * Disables local report generation.
+     * Use this when reports are unnecessary or should be handled exclusively by sinks.
+     */
     WithoutReports(): LoadStrikeRunner;
+    /**
+     * Builds the current configuration into a runnable context.
+     * Use this when you want to inspect or reuse the final run settings before execution.
+     */
     buildContext(): LoadStrikeContext;
+    /**
+     * Builds the current configuration into a runnable context.
+     * Use this when you want to inspect or reuse the final run settings before execution.
+     */
     BuildContext(): LoadStrikeContext;
     run(args?: string[]): Promise<LoadStrikeRunResult>;
     Run(args?: string[]): Promise<LoadStrikeRunResult>;