@launchdarkly/mcp-server 0.7.0 → 0.7.2

package/src/models/components/metricv2rep.ts

@@ -0,0 +1,201 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  Link,
+  Link$inboundSchema,
+  Link$Outbound,
+  Link$outboundSchema,
+} from "./link.js";
+
+/**
+ * The kind of event the metric tracks
+ */
+export const MetricV2RepKind = {
+  Pageview: "pageview",
+  Click: "click",
+  Custom: "custom",
+  Trace: "trace",
+} as const;
+/**
+ * The kind of event the metric tracks
+ */
+export type MetricV2RepKind = ClosedEnum<typeof MetricV2RepKind>;
+
+/**
+ * The type of unit aggregation to use for the metric
+ */
+export const MetricV2RepUnitAggregationType = {
+  Sum: "sum",
+  Average: "average",
+  CountDistinct: "count_distinct",
+} as const;
+/**
+ * The type of unit aggregation to use for the metric
+ */
+export type MetricV2RepUnitAggregationType = ClosedEnum<
+  typeof MetricV2RepUnitAggregationType
+>;
+
+/**
+ * The method for analyzing metric events
+ */
+export const MetricV2RepAnalysisType = {
+  Mean: "mean",
+  Percentile: "percentile",
+} as const;
+/**
+ * The method for analyzing metric events
+ */
+export type MetricV2RepAnalysisType = ClosedEnum<
+  typeof MetricV2RepAnalysisType
+>;
+
+export type MetricV2Rep = {
+  /**
+   * The metric key
+   */
+  key: string;
+  /**
+   * The version ID of the metric
+   */
+  versionId?: string | undefined;
+  /**
+   * The metric name
+   */
+  name: string;
+  /**
+   * The kind of event the metric tracks
+   */
+  kind: MetricV2RepKind;
+  /**
+   * For custom metrics, whether to track numeric changes in value against a baseline (<code>true</code>) or to track a conversion when an end user takes an action (<code>false</code>).
+   */
+  isNumeric?: boolean | undefined;
+  /**
+   * The type of unit aggregation to use for the metric
+   */
+  unitAggregationType?: MetricV2RepUnitAggregationType | undefined;
+  /**
+   * The method for analyzing metric events
+   */
+  analysisType?: MetricV2RepAnalysisType | undefined;
+  /**
+   * The event key sent with the metric. Only relevant for custom metrics.
+   */
+  eventKey?: string | undefined;
+  /**
+   * The context kind used as the analysis unit for this metric in the experiment iteration
+   */
+  analysisUnit?: string | undefined;
+  /**
+   * The location and content type of related resources
+   */
+  links: { [k: string]: Link };
+};
+
+/** @internal */
+export const MetricV2RepKind$inboundSchema: z.ZodNativeEnum<
+  typeof MetricV2RepKind
+> = z.nativeEnum(MetricV2RepKind);
+/** @internal */
+export const MetricV2RepKind$outboundSchema: z.ZodNativeEnum<
+  typeof MetricV2RepKind
+> = MetricV2RepKind$inboundSchema;
+
+/** @internal */
+export const MetricV2RepUnitAggregationType$inboundSchema: z.ZodNativeEnum<
+  typeof MetricV2RepUnitAggregationType
+> = z.nativeEnum(MetricV2RepUnitAggregationType);
+/** @internal */
+export const MetricV2RepUnitAggregationType$outboundSchema: z.ZodNativeEnum<
+  typeof MetricV2RepUnitAggregationType
+> = MetricV2RepUnitAggregationType$inboundSchema;
+
+/** @internal */
+export const MetricV2RepAnalysisType$inboundSchema: z.ZodNativeEnum<
+  typeof MetricV2RepAnalysisType
+> = z.nativeEnum(MetricV2RepAnalysisType);
+/** @internal */
+export const MetricV2RepAnalysisType$outboundSchema: z.ZodNativeEnum<
+  typeof MetricV2RepAnalysisType
+> = MetricV2RepAnalysisType$inboundSchema;
+
+/** @internal */
+export const MetricV2Rep$inboundSchema: z.ZodType<
+  MetricV2Rep,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  _versionId: z.string().optional(),
+  name: z.string(),
+  kind: MetricV2RepKind$inboundSchema,
+  isNumeric: z.boolean().optional(),
+  unitAggregationType: MetricV2RepUnitAggregationType$inboundSchema.optional(),
+  analysisType: MetricV2RepAnalysisType$inboundSchema.optional(),
+  eventKey: z.string().optional(),
+  analysisUnit: z.string().optional(),
+  _links: z.record(Link$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "_versionId": "versionId",
+    "_links": "links",
+  });
+});
+/** @internal */
+export type MetricV2Rep$Outbound = {
+  key: string;
+  _versionId?: string | undefined;
+  name: string;
+  kind: string;
+  isNumeric?: boolean | undefined;
+  unitAggregationType?: string | undefined;
+  analysisType?: string | undefined;
+  eventKey?: string | undefined;
+  analysisUnit?: string | undefined;
+  _links: { [k: string]: Link$Outbound };
+};
+
+/** @internal */
+export const MetricV2Rep$outboundSchema: z.ZodType<
+  MetricV2Rep$Outbound,
+  z.ZodTypeDef,
+  MetricV2Rep
+> = z.object({
+  key: z.string(),
+  versionId: z.string().optional(),
+  name: z.string(),
+  kind: MetricV2RepKind$outboundSchema,
+  isNumeric: z.boolean().optional(),
+  unitAggregationType: MetricV2RepUnitAggregationType$outboundSchema.optional(),
+  analysisType: MetricV2RepAnalysisType$outboundSchema.optional(),
+  eventKey: z.string().optional(),
+  analysisUnit: z.string().optional(),
+  links: z.record(Link$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    versionId: "_versionId",
+    links: "_links",
+  });
+});
+
+export function metricV2RepToJSON(metricV2Rep: MetricV2Rep): string {
+  return JSON.stringify(MetricV2Rep$outboundSchema.parse(metricV2Rep));
+}
+export function metricV2RepFromJSON(
+  jsonString: string,
+): SafeParseResult<MetricV2Rep, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MetricV2Rep$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MetricV2Rep' from JSON`,
+  );
+}

package/src/models/components/mutablefieldsbystatusrep.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type MutableFieldsByStatusRep = {
+  notStarted?: { [k: string]: Array<string> } | undefined;
+  running?: { [k: string]: Array<string> } | undefined;
+  stopped?: { [k: string]: Array<string> } | undefined;
+};
+
+/** @internal */
+export const MutableFieldsByStatusRep$inboundSchema: z.ZodType<
+  MutableFieldsByStatusRep,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  not_started: z.record(z.array(z.string())).optional(),
+  running: z.record(z.array(z.string())).optional(),
+  stopped: z.record(z.array(z.string())).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "not_started": "notStarted",
+  });
+});
+/** @internal */
+export type MutableFieldsByStatusRep$Outbound = {
+  not_started?: { [k: string]: Array<string> } | undefined;
+  running?: { [k: string]: Array<string> } | undefined;
+  stopped?: { [k: string]: Array<string> } | undefined;
+};
+
+/** @internal */
+export const MutableFieldsByStatusRep$outboundSchema: z.ZodType<
+  MutableFieldsByStatusRep$Outbound,
+  z.ZodTypeDef,
+  MutableFieldsByStatusRep
+> = z.object({
+  notStarted: z.record(z.array(z.string())).optional(),
+  running: z.record(z.array(z.string())).optional(),
+  stopped: z.record(z.array(z.string())).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    notStarted: "not_started",
+  });
+});
+
+export function mutableFieldsByStatusRepToJSON(
+  mutableFieldsByStatusRep: MutableFieldsByStatusRep,
+): string {
+  return JSON.stringify(
+    MutableFieldsByStatusRep$outboundSchema.parse(mutableFieldsByStatusRep),
+  );
+}
+export function mutableFieldsByStatusRepFromJSON(
+  jsonString: string,
+): SafeParseResult<MutableFieldsByStatusRep, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MutableFieldsByStatusRep$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MutableFieldsByStatusRep' from JSON`,
+  );
+}

package/src/models/components/parameterrep.ts

@@ -0,0 +1,51 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ParameterRep = {
+  variationId?: string | undefined;
+  flagKey?: string | undefined;
+};
+
+/** @internal */
+export const ParameterRep$inboundSchema: z.ZodType<
+  ParameterRep,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  variationId: z.string().optional(),
+  flagKey: z.string().optional(),
+});
+/** @internal */
+export type ParameterRep$Outbound = {
+  variationId?: string | undefined;
+  flagKey?: string | undefined;
+};
+
+/** @internal */
+export const ParameterRep$outboundSchema: z.ZodType<
+  ParameterRep$Outbound,
+  z.ZodTypeDef,
+  ParameterRep
+> = z.object({
+  variationId: z.string().optional(),
+  flagKey: z.string().optional(),
+});
+
+export function parameterRepToJSON(parameterRep: ParameterRep): string {
+  return JSON.stringify(ParameterRep$outboundSchema.parse(parameterRep));
+}
+export function parameterRepFromJSON(
+  jsonString: string,
+): SafeParseResult<ParameterRep, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ParameterRep$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ParameterRep' from JSON`,
+  );
+}

package/src/models/components/relatedaiconfig.ts

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type RelatedAIConfig = {
+  key: string;
+};
+
+/** @internal */
+export const RelatedAIConfig$inboundSchema: z.ZodType<
+  RelatedAIConfig,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+});
+/** @internal */
+export type RelatedAIConfig$Outbound = {
+  key: string;
+};
+
+/** @internal */
+export const RelatedAIConfig$outboundSchema: z.ZodType<
+  RelatedAIConfig$Outbound,
+  z.ZodTypeDef,
+  RelatedAIConfig
+> = z.object({
+  key: z.string(),
+});
+
+export function relatedAIConfigToJSON(
+  relatedAIConfig: RelatedAIConfig,
+): string {
+  return JSON.stringify(RelatedAIConfig$outboundSchema.parse(relatedAIConfig));
+}
+export function relatedAIConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<RelatedAIConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RelatedAIConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RelatedAIConfig' from JSON`,
+  );
+}

package/src/models/components/relatedexperiment.ts

@@ -0,0 +1,51 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type RelatedExperiment = {
+  key: string;
+};
+
+/** @internal */
+export const RelatedExperiment$inboundSchema: z.ZodType<
+  RelatedExperiment,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+});
+/** @internal */
+export type RelatedExperiment$Outbound = {
+  key: string;
+};
+
+/** @internal */
+export const RelatedExperiment$outboundSchema: z.ZodType<
+  RelatedExperiment$Outbound,
+  z.ZodTypeDef,
+  RelatedExperiment
+> = z.object({
+  key: z.string(),
+});
+
+export function relatedExperimentToJSON(
+  relatedExperiment: RelatedExperiment,
+): string {
+  return JSON.stringify(
+    RelatedExperiment$outboundSchema.parse(relatedExperiment),
+  );
+}
+export function relatedExperimentFromJSON(
+  jsonString: string,
+): SafeParseResult<RelatedExperiment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RelatedExperiment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RelatedExperiment' from JSON`,
+  );
+}

package/src/models/components/relatedflag.ts

@@ -0,0 +1,47 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type RelatedFlag = {
+  key: string;
+};
+
+/** @internal */
+export const RelatedFlag$inboundSchema: z.ZodType<
+  RelatedFlag,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+});
+/** @internal */
+export type RelatedFlag$Outbound = {
+  key: string;
+};
+
+/** @internal */
+export const RelatedFlag$outboundSchema: z.ZodType<
+  RelatedFlag$Outbound,
+  z.ZodTypeDef,
+  RelatedFlag
+> = z.object({
+  key: z.string(),
+});
+
+export function relatedFlagToJSON(relatedFlag: RelatedFlag): string {
+  return JSON.stringify(RelatedFlag$outboundSchema.parse(relatedFlag));
+}
+export function relatedFlagFromJSON(
+  jsonString: string,
+): SafeParseResult<RelatedFlag, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RelatedFlag$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RelatedFlag' from JSON`,
+  );
+}

package/src/models/components/rule.ts

@@ -39,7 +39,7 @@ export type Rule = {
    */
   clauses: Array<Clause>;
   /**
-   * Whether LaunchDarkly tracks events for this rule
+   * Whether the SDK sends a detailed event for every evaluation of this rule, instead of only summary counts. Required for Data Export, but doesn't enable Data Export on its own.
    */
   trackEvents: boolean;
   /**

package/src/models/components/staleflagdata.ts

@@ -0,0 +1,64 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type StaleFlagData = {
+  /**
+   * Whether the flag is ready for code removal
+   */
+  readyForCodeRemoval?: boolean | undefined;
+  /**
+   * Whether the flag is ready to be archived
+   */
+  readyToArchive?: boolean | undefined;
+  /**
+   * If a third-party system helps clean up the flag, the ID from that system
+   */
+  cleanupId?: string | undefined;
+};
+
+/** @internal */
+export const StaleFlagData$inboundSchema: z.ZodType<
+  StaleFlagData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  readyForCodeRemoval: z.boolean().optional(),
+  readyToArchive: z.boolean().optional(),
+  cleanupId: z.string().optional(),
+});
+/** @internal */
+export type StaleFlagData$Outbound = {
+  readyForCodeRemoval?: boolean | undefined;
+  readyToArchive?: boolean | undefined;
+  cleanupId?: string | undefined;
+};
+
+/** @internal */
+export const StaleFlagData$outboundSchema: z.ZodType<
+  StaleFlagData$Outbound,
+  z.ZodTypeDef,
+  StaleFlagData
+> = z.object({
+  readyForCodeRemoval: z.boolean().optional(),
+  readyToArchive: z.boolean().optional(),
+  cleanupId: z.string().optional(),
+});
+
+export function staleFlagDataToJSON(staleFlagData: StaleFlagData): string {
+  return JSON.stringify(StaleFlagData$outboundSchema.parse(staleFlagData));
+}
+export function staleFlagDataFromJSON(
+  jsonString: string,
+): SafeParseResult<StaleFlagData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StaleFlagData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StaleFlagData' from JSON`,
+  );
+}

package/src/models/components/treatmentinput.ts

@@ -0,0 +1,77 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  TreatmentParameterInput,
+  TreatmentParameterInput$inboundSchema,
+  TreatmentParameterInput$Outbound,
+  TreatmentParameterInput$outboundSchema,
+} from "./treatmentparameterinput.js";
+
+export type TreatmentInput = {
+  /**
+   * The treatment name
+   */
+  name: string;
+  /**
+   * Whether this treatment is the baseline to compare other treatments against
+   */
+  baseline: boolean;
+  /**
+   * The percentage of traffic allocated to this treatment during the iteration
+   */
+  allocationPercent: string;
+  /**
+   * Details on the flag and variation to use for this treatment
+   */
+  parameters: Array<TreatmentParameterInput>;
+};
+
+/** @internal */
+export const TreatmentInput$inboundSchema: z.ZodType<
+  TreatmentInput,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+  baseline: z.boolean(),
+  allocationPercent: z.string(),
+  parameters: z.array(TreatmentParameterInput$inboundSchema),
+});
+/** @internal */
+export type TreatmentInput$Outbound = {
+  name: string;
+  baseline: boolean;
+  allocationPercent: string;
+  parameters: Array<TreatmentParameterInput$Outbound>;
+};
+
+/** @internal */
+export const TreatmentInput$outboundSchema: z.ZodType<
+  TreatmentInput$Outbound,
+  z.ZodTypeDef,
+  TreatmentInput
+> = z.object({
+  name: z.string(),
+  baseline: z.boolean(),
+  allocationPercent: z.string(),
+  parameters: z.array(TreatmentParameterInput$outboundSchema),
+});
+
+export function treatmentInputToJSON(treatmentInput: TreatmentInput): string {
+  return JSON.stringify(TreatmentInput$outboundSchema.parse(treatmentInput));
+}
+export function treatmentInputFromJSON(
+  jsonString: string,
+): SafeParseResult<TreatmentInput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TreatmentInput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TreatmentInput' from JSON`,
+  );
+}

package/src/models/components/treatmentparameterinput.ts

@@ -0,0 +1,61 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type TreatmentParameterInput = {
+  /**
+   * The flag key
+   */
+  flagKey: string;
+  /**
+   * The ID of the flag variation
+   */
+  variationId: string;
+};
+
+/** @internal */
+export const TreatmentParameterInput$inboundSchema: z.ZodType<
+  TreatmentParameterInput,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  flagKey: z.string(),
+  variationId: z.string(),
+});
+/** @internal */
+export type TreatmentParameterInput$Outbound = {
+  flagKey: string;
+  variationId: string;
+};
+
+/** @internal */
+export const TreatmentParameterInput$outboundSchema: z.ZodType<
+  TreatmentParameterInput$Outbound,
+  z.ZodTypeDef,
+  TreatmentParameterInput
+> = z.object({
+  flagKey: z.string(),
+  variationId: z.string(),
+});
+
+export function treatmentParameterInputToJSON(
+  treatmentParameterInput: TreatmentParameterInput,
+): string {
+  return JSON.stringify(
+    TreatmentParameterInput$outboundSchema.parse(treatmentParameterInput),
+  );
+}
+export function treatmentParameterInputFromJSON(
+  jsonString: string,
+): SafeParseResult<TreatmentParameterInput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TreatmentParameterInput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TreatmentParameterInput' from JSON`,
+  );
+}