@launchdarkly/mcp-server/dist/commonjs/models/components/iterationrep.d.ts

The local [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server for [LaunchDarkly](https://launchdarkly.com/) federal and European Union (EU) environments.

import * as z from "zod/v3";
import { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
import { CovariateInfoRep, CovariateInfoRep$Outbound } from "./covariateinforep.js";
import { DependentMetricGroupRepWithMetrics, DependentMetricGroupRepWithMetrics$Outbound } from "./dependentmetricgrouprepwithmetrics.js";
import { DependentMetricOrMetricGroupRep, DependentMetricOrMetricGroupRep$Outbound } from "./dependentmetricormetricgrouprep.js";
import { FlagRep, FlagRep$Outbound } from "./flagrep.js";
import { LayerSnapshotRep, LayerSnapshotRep$Outbound } from "./layersnapshotrep.js";
import { MetricV2Rep, MetricV2Rep$Outbound } from "./metricv2rep.js";
import { TreatmentRep, TreatmentRep$Outbound } from "./treatmentrep.js";
/**
 * The status of the iteration: <code>not_started</code>, <code>running</code>, <code>stopped</code>
 */
export declare const Status: {
    readonly NotStarted: "not_started";
    readonly Running: "running";
    readonly Stopped: "stopped";
};
/**
 * The status of the iteration: <code>not_started</code>, <code>running</code>, <code>stopped</code>
 */
export type Status = ClosedEnum<typeof Status>;
export type IterationRep = {
    /**
     * The iteration ID
     */
    id?: string | undefined;
    /**
     * The expected outcome of this experiment
     */
    hypothesis?: string | undefined;
    /**
     * The status of the iteration: <code>not_started</code>, <code>running</code>, <code>stopped</code>
     */
    status: Status;
    createdAt: number;
    startedAt?: number | undefined;
    endedAt?: number | undefined;
    /**
     * The ID of the treatment chosen when the experiment stopped
     */
    winningTreatmentId?: string | undefined;
    /**
     * The reason you stopped the experiment
     */
    winningReason?: string | undefined;
    /**
     * Whether the experiment may reassign traffic to different variations when the experiment audience changes (true) or must keep all traffic assigned to its initial variation (false).
     */
    canReshuffleTraffic?: boolean | undefined;
    /**
     * Details on the flag used in this experiment
     */
    flags?: {
        [k: string]: FlagRep;
    } | undefined;
    /**
     * The cadence (in milliseconds) to update the allocation. Only present for multi-armed bandits.
     */
    reallocationFrequencyMillis?: number | undefined;
    /**
     * The current version that the iteration is on
     */
    version?: number | undefined;
    primaryMetric?: DependentMetricOrMetricGroupRep | undefined;
    primarySingleMetric?: MetricV2Rep | undefined;
    primaryFunnel?: DependentMetricGroupRepWithMetrics | undefined;
    /**
     * The unit of randomization for this iteration
     */
    randomizationUnit?: string | undefined;
    /**
     * The available attribute filters for this iteration
     */
    attributes?: Array<string> | undefined;
    /**
     * Details on the variations you are testing in the experiment
     */
    treatments?: Array<TreatmentRep> | undefined;
    /**
     * Deprecated, use <code>metrics</code> instead. Details on the secondary metrics for this experiment.
     *
     * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
     */
    secondaryMetrics?: Array<MetricV2Rep> | undefined;
    /**
     * Details on the metrics for this experiment
     */
    metrics?: Array<DependentMetricOrMetricGroupRep> | undefined;
    layerSnapshot?: LayerSnapshotRep | undefined;
    covariateInfo?: CovariateInfoRep | undefined;
};
/** @internal */
export declare const Status$inboundSchema: z.ZodNativeEnum<typeof Status>;
/** @internal */
export declare const Status$outboundSchema: z.ZodNativeEnum<typeof Status>;
/** @internal */
export declare const IterationRep$inboundSchema: z.ZodType<IterationRep, z.ZodTypeDef, unknown>;
/** @internal */
export type IterationRep$Outbound = {
    _id?: string | undefined;
    hypothesis?: string | undefined;
    status: string;
    createdAt: number;
    startedAt?: number | undefined;
    endedAt?: number | undefined;
    winningTreatmentId?: string | undefined;
    winningReason?: string | undefined;
    canReshuffleTraffic?: boolean | undefined;
    flags?: {
        [k: string]: FlagRep$Outbound;
    } | undefined;
    reallocationFrequencyMillis?: number | undefined;
    version?: number | undefined;
    primaryMetric?: DependentMetricOrMetricGroupRep$Outbound | undefined;
    primarySingleMetric?: MetricV2Rep$Outbound | undefined;
    primaryFunnel?: DependentMetricGroupRepWithMetrics$Outbound | undefined;
    randomizationUnit?: string | undefined;
    attributes?: Array<string> | undefined;
    treatments?: Array<TreatmentRep$Outbound> | undefined;
    secondaryMetrics?: Array<MetricV2Rep$Outbound> | undefined;
    metrics?: Array<DependentMetricOrMetricGroupRep$Outbound> | undefined;
    layerSnapshot?: LayerSnapshotRep$Outbound | undefined;
    covariateInfo?: CovariateInfoRep$Outbound | undefined;
};
/** @internal */
export declare const IterationRep$outboundSchema: z.ZodType<IterationRep$Outbound, z.ZodTypeDef, IterationRep>;
export declare function iterationRepToJSON(iterationRep: IterationRep): string;
export declare function iterationRepFromJSON(jsonString: string): SafeParseResult<IterationRep, SDKValidationError>;
//# sourceMappingURL=iterationrep.d.ts.map