@launchdarkly/mcp-server 0.7.1 → 0.7.2

package/src/models/components/approvalsettings.ts

@@ -45,10 +45,6 @@ export type ApprovalSettings = {
    * Optional field for integration configuration ID of a custom approval integration. This is an Enterprise-only feature.
    */
   serviceKindConfigurationId?: string | undefined;
-  /**
-   * The kind of resource for which the approval settings apply, for example, flag or segment
-   */
-  resourceKind?: string | undefined;
 };
 
 /** @internal */
@@ -67,7 +63,6 @@ export const ApprovalSettings$inboundSchema: z.ZodType<
   serviceConfig: z.record(z.any()),
   requiredApprovalTags: z.array(z.string()),
   serviceKindConfigurationId: z.string().optional(),
-  resourceKind: z.string().optional(),
 });
 /** @internal */
 export type ApprovalSettings$Outbound = {
@@ -81,7 +76,6 @@ export type ApprovalSettings$Outbound = {
   serviceConfig: { [k: string]: any };
   requiredApprovalTags: Array<string>;
   serviceKindConfigurationId?: string | undefined;
-  resourceKind?: string | undefined;
 };
 
 /** @internal */
@@ -100,7 +94,6 @@ export const ApprovalSettings$outboundSchema: z.ZodType<
   serviceConfig: z.record(z.any()),
   requiredApprovalTags: z.array(z.string()),
   serviceKindConfigurationId: z.string().optional(),
-  resourceKind: z.string().optional(),
 });
 
 export function approvalSettingsToJSON(

package/src/models/components/auditlogentrylistingrep.ts

@@ -31,6 +31,24 @@ import {
   ParentResourceRep$Outbound,
   ParentResourceRep$outboundSchema,
 } from "./parentresourcerep.js";
+import {
+  RelatedAIConfig,
+  RelatedAIConfig$inboundSchema,
+  RelatedAIConfig$Outbound,
+  RelatedAIConfig$outboundSchema,
+} from "./relatedaiconfig.js";
+import {
+  RelatedExperiment,
+  RelatedExperiment$inboundSchema,
+  RelatedExperiment$Outbound,
+  RelatedExperiment$outboundSchema,
+} from "./relatedexperiment.js";
+import {
+  RelatedFlag,
+  RelatedFlag$inboundSchema,
+  RelatedFlag$Outbound,
+  RelatedFlag$outboundSchema,
+} from "./relatedflag.js";
 import {
   ResourceAccess,
   ResourceAccess$inboundSchema,
@@ -91,6 +109,9 @@ export type AuditLogEntryListingRep = {
    * Optional comment for the audit log entry
    */
   comment?: string | undefined;
+  relatedFlag?: RelatedFlag | undefined;
+  relatedExperiment?: RelatedExperiment | undefined;
+  relatedAIConfig?: RelatedAIConfig | undefined;
   subject?: SubjectDataRep | undefined;
   member?: MemberDataRep | undefined;
   token?: TokenSummary | undefined;
@@ -123,6 +144,9 @@ export const AuditLogEntryListingRep$inboundSchema: z.ZodType<
   description: z.string(),
   shortDescription: z.string(),
   comment: z.string().optional(),
+  relatedFlag: RelatedFlag$inboundSchema.optional(),
+  relatedExperiment: RelatedExperiment$inboundSchema.optional(),
+  relatedAIConfig: RelatedAIConfig$inboundSchema.optional(),
   subject: SubjectDataRep$inboundSchema.optional(),
   member: MemberDataRep$inboundSchema.optional(),
   token: TokenSummary$inboundSchema.optional(),
@@ -150,6 +174,9 @@ export type AuditLogEntryListingRep$Outbound = {
   description: string;
   shortDescription: string;
   comment?: string | undefined;
+  relatedFlag?: RelatedFlag$Outbound | undefined;
+  relatedExperiment?: RelatedExperiment$Outbound | undefined;
+  relatedAIConfig?: RelatedAIConfig$Outbound | undefined;
   subject?: SubjectDataRep$Outbound | undefined;
   member?: MemberDataRep$Outbound | undefined;
   token?: TokenSummary$Outbound | undefined;
@@ -176,6 +203,9 @@ export const AuditLogEntryListingRep$outboundSchema: z.ZodType<
   description: z.string(),
   shortDescription: z.string(),
   comment: z.string().optional(),
+  relatedFlag: RelatedFlag$outboundSchema.optional(),
+  relatedExperiment: RelatedExperiment$outboundSchema.optional(),
+  relatedAIConfig: RelatedAIConfig$outboundSchema.optional(),
   subject: SubjectDataRep$outboundSchema.optional(),
   member: MemberDataRep$outboundSchema.optional(),
   token: TokenSummary$outboundSchema.optional(),

package/src/models/components/authorizedappdatarep.ts

@@ -28,10 +28,18 @@ export type AuthorizedAppDataRep = {
    * The authorized application name
    */
   name?: string | undefined;
+  /**
+   * The icon for this authorized application, if it has one
+   */
+  iconUrl?: string | undefined;
   /**
    * The name of the maintainer for this authorized application
    */
   maintainerName?: string | undefined;
+  /**
+   * Whether this application acted on behalf of the member in this entry. When true, the member and the application are co-authors of the change rather than the member acting alone. Omitted for applications that act on their own.
+   */
+  isAgent?: boolean | undefined;
 };
 
 /** @internal */
@@ -44,7 +52,9 @@ export const AuthorizedAppDataRep$inboundSchema: z.ZodType<
   _id: z.string().optional(),
   isScim: z.boolean().optional(),
   name: z.string().optional(),
+  iconUrl: z.string().optional(),
   maintainerName: z.string().optional(),
+  isAgent: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
     "_links": "links",
@@ -57,7 +67,9 @@ export type AuthorizedAppDataRep$Outbound = {
   _id?: string | undefined;
   isScim?: boolean | undefined;
   name?: string | undefined;
+  iconUrl?: string | undefined;
   maintainerName?: string | undefined;
+  isAgent?: boolean | undefined;
 };
 
 /** @internal */
@@ -70,7 +82,9 @@ export const AuthorizedAppDataRep$outboundSchema: z.ZodType<
   id: z.string().optional(),
   isScim: z.boolean().optional(),
   name: z.string().optional(),
+  iconUrl: z.string().optional(),
   maintainerName: z.string().optional(),
+  isAgent: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
     links: "_links",

package/src/models/components/classifier.ts

@@ -0,0 +1,83 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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";
+
+export const ClassifierType = {
+  Bool: "bool",
+  Float: "float",
+  Enum: "enum",
+} as const;
+export type ClassifierType = ClosedEnum<typeof ClassifierType>;
+
+export type Classifier = {
+  key: string;
+  type: ClassifierType;
+  instructions: string;
+  /**
+   * Type-specific criteria. An enum classifier uses a map of option keys to descriptions.
+   *
+   * @remarks
+   * A float classifier uses an ordered list of level labels. A bool classifier uses optional
+   * true and false descriptions.
+   */
+  criteria?: any | undefined;
+};
+
+/** @internal */
+export const ClassifierType$inboundSchema: z.ZodNativeEnum<
+  typeof ClassifierType
+> = z.nativeEnum(ClassifierType);
+/** @internal */
+export const ClassifierType$outboundSchema: z.ZodNativeEnum<
+  typeof ClassifierType
+> = ClassifierType$inboundSchema;
+
+/** @internal */
+export const Classifier$inboundSchema: z.ZodType<
+  Classifier,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  type: ClassifierType$inboundSchema,
+  instructions: z.string(),
+  criteria: z.any().optional(),
+});
+/** @internal */
+export type Classifier$Outbound = {
+  key: string;
+  type: string;
+  instructions: string;
+  criteria?: any | undefined;
+};
+
+/** @internal */
+export const Classifier$outboundSchema: z.ZodType<
+  Classifier$Outbound,
+  z.ZodTypeDef,
+  Classifier
+> = z.object({
+  key: z.string(),
+  type: ClassifierType$outboundSchema,
+  instructions: z.string(),
+  criteria: z.any().optional(),
+});
+
+export function classifierToJSON(classifier: Classifier): string {
+  return JSON.stringify(Classifier$outboundSchema.parse(classifier));
+}
+export function classifierFromJSON(
+  jsonString: string,
+): SafeParseResult<Classifier, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Classifier$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Classifier' from JSON`,
+  );
+}

package/src/models/components/covariateinforep.ts

@@ -0,0 +1,65 @@
+/*
+ * 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 CovariateInfoRep = {
+  /**
+   * The ID of the covariate matrix
+   */
+  id: string;
+  /**
+   * The file name of the uploaded covariate matrix
+   */
+  fileName: string;
+  createdAt: number;
+};
+
+/** @internal */
+export const CovariateInfoRep$inboundSchema: z.ZodType<
+  CovariateInfoRep,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  fileName: z.string(),
+  createdAt: z.number().int(),
+});
+/** @internal */
+export type CovariateInfoRep$Outbound = {
+  id: string;
+  fileName: string;
+  createdAt: number;
+};
+
+/** @internal */
+export const CovariateInfoRep$outboundSchema: z.ZodType<
+  CovariateInfoRep$Outbound,
+  z.ZodTypeDef,
+  CovariateInfoRep
+> = z.object({
+  id: z.string(),
+  fileName: z.string(),
+  createdAt: z.number().int(),
+});
+
+export function covariateInfoRepToJSON(
+  covariateInfoRep: CovariateInfoRep,
+): string {
+  return JSON.stringify(
+    CovariateInfoRep$outboundSchema.parse(covariateInfoRep),
+  );
+}
+export function covariateInfoRepFromJSON(
+  jsonString: string,
+): SafeParseResult<CovariateInfoRep, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CovariateInfoRep$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CovariateInfoRep' from JSON`,
+  );
+}

package/src/models/components/denominatorpost.ts

@@ -0,0 +1,135 @@
+/*
+ * 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 {
+  EventFilter,
+  EventFilter$inboundSchema,
+  EventFilter$Outbound,
+  EventFilter$outboundSchema,
+} from "./eventfilter.js";
+import {
+  MetricDataSourceRefRep,
+  MetricDataSourceRefRep$inboundSchema,
+  MetricDataSourceRefRep$Outbound,
+  MetricDataSourceRefRep$outboundSchema,
+} from "./metricdatasourcerefrep.js";
+
+export type DenominatorPost = {
+  /**
+   * The warehouse event column for the denominator. Required.
+   */
+  eventName?: string | undefined;
+  /**
+   * Whether the denominator aggregates a numeric value
+   */
+  isNumeric?: boolean | undefined;
+  dataSource?: MetricDataSourceRefRep | undefined;
+  /**
+   * How individual unit values are aggregated. One of: average, sum, count_distinct
+   */
+  unitAggregationType?: string | undefined;
+  /**
+   * The warehouse column to use for counting distinct values. Required when the unitAggregationType is count_distinct.
+   */
+  unitAggregationField?: string | undefined;
+  /**
+   * For a numeric denominator, the column holding the numeric value. Overrides the value column mapped on the denominator data source.
+   */
+  valueColumn?: string | undefined;
+  filters?: EventFilter | undefined;
+  /**
+   * Start of the measurement window in milliseconds
+   */
+  windowStartOffset?: number | undefined;
+  /**
+   * End of the measurement window in milliseconds
+   */
+  windowEndOffset?: number | undefined;
+  /**
+   * Lower winsorization percentile in the open interval (0, 100)
+   */
+  winsorLowerPercentile?: number | undefined;
+  /**
+   * Upper winsorization percentile in the open interval (0, 100)
+   */
+  winsorUpperPercentile?: number | undefined;
+  /**
+   * When true, includes imputed zeros in the percentile bound calculation
+   */
+  winsorIncludeImputed?: boolean | undefined;
+};
+
+/** @internal */
+export const DenominatorPost$inboundSchema: z.ZodType<
+  DenominatorPost,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  eventName: z.string().optional(),
+  isNumeric: z.boolean().optional(),
+  dataSource: MetricDataSourceRefRep$inboundSchema.optional(),
+  unitAggregationType: z.string().optional(),
+  unitAggregationField: z.string().optional(),
+  valueColumn: z.string().optional(),
+  filters: EventFilter$inboundSchema.optional(),
+  windowStartOffset: z.number().int().optional(),
+  windowEndOffset: z.number().int().optional(),
+  winsorLowerPercentile: z.number().optional(),
+  winsorUpperPercentile: z.number().optional(),
+  winsorIncludeImputed: z.boolean().optional(),
+});
+/** @internal */
+export type DenominatorPost$Outbound = {
+  eventName?: string | undefined;
+  isNumeric?: boolean | undefined;
+  dataSource?: MetricDataSourceRefRep$Outbound | undefined;
+  unitAggregationType?: string | undefined;
+  unitAggregationField?: string | undefined;
+  valueColumn?: string | undefined;
+  filters?: EventFilter$Outbound | undefined;
+  windowStartOffset?: number | undefined;
+  windowEndOffset?: number | undefined;
+  winsorLowerPercentile?: number | undefined;
+  winsorUpperPercentile?: number | undefined;
+  winsorIncludeImputed?: boolean | undefined;
+};
+
+/** @internal */
+export const DenominatorPost$outboundSchema: z.ZodType<
+  DenominatorPost$Outbound,
+  z.ZodTypeDef,
+  DenominatorPost
+> = z.object({
+  eventName: z.string().optional(),
+  isNumeric: z.boolean().optional(),
+  dataSource: MetricDataSourceRefRep$outboundSchema.optional(),
+  unitAggregationType: z.string().optional(),
+  unitAggregationField: z.string().optional(),
+  valueColumn: z.string().optional(),
+  filters: EventFilter$outboundSchema.optional(),
+  windowStartOffset: z.number().int().optional(),
+  windowEndOffset: z.number().int().optional(),
+  winsorLowerPercentile: z.number().optional(),
+  winsorUpperPercentile: z.number().optional(),
+  winsorIncludeImputed: z.boolean().optional(),
+});
+
+export function denominatorPostToJSON(
+  denominatorPost: DenominatorPost,
+): string {
+  return JSON.stringify(DenominatorPost$outboundSchema.parse(denominatorPost));
+}
+export function denominatorPostFromJSON(
+  jsonString: string,
+): SafeParseResult<DenominatorPost, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DenominatorPost$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DenominatorPost' from JSON`,
+  );
+}

package/src/models/components/dependentexperimentrep.ts

@@ -0,0 +1,105 @@
+/*
+ * 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";
+import {
+  Link,
+  Link$inboundSchema,
+  Link$Outbound,
+  Link$outboundSchema,
+} from "./link.js";
+
+export type DependentExperimentRep = {
+  /**
+   * The experiment key
+   */
+  key: string;
+  /**
+   * The experiment name
+   */
+  name: string;
+  /**
+   * The environment ID
+   */
+  environmentId: string;
+  /**
+   * The environment key
+   */
+  environmentKey: string;
+  creationDate: number;
+  archivedDate?: number | undefined;
+  /**
+   * The location and content type of related resources
+   */
+  links: { [k: string]: Link };
+};
+
+/** @internal */
+export const DependentExperimentRep$inboundSchema: z.ZodType<
+  DependentExperimentRep,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+  environmentId: z.string(),
+  environmentKey: z.string(),
+  creationDate: z.number().int(),
+  archivedDate: z.number().int().optional(),
+  _links: z.record(Link$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "_links": "links",
+  });
+});
+/** @internal */
+export type DependentExperimentRep$Outbound = {
+  key: string;
+  name: string;
+  environmentId: string;
+  environmentKey: string;
+  creationDate: number;
+  archivedDate?: number | undefined;
+  _links: { [k: string]: Link$Outbound };
+};
+
+/** @internal */
+export const DependentExperimentRep$outboundSchema: z.ZodType<
+  DependentExperimentRep$Outbound,
+  z.ZodTypeDef,
+  DependentExperimentRep
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+  environmentId: z.string(),
+  environmentKey: z.string(),
+  creationDate: z.number().int(),
+  archivedDate: z.number().int().optional(),
+  links: z.record(Link$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    links: "_links",
+  });
+});
+
+export function dependentExperimentRepToJSON(
+  dependentExperimentRep: DependentExperimentRep,
+): string {
+  return JSON.stringify(
+    DependentExperimentRep$outboundSchema.parse(dependentExperimentRep),
+  );
+}
+export function dependentExperimentRepFromJSON(
+  jsonString: string,
+): SafeParseResult<DependentExperimentRep, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DependentExperimentRep$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DependentExperimentRep' from JSON`,
+  );
+}

package/src/models/components/dependentmetricgrouprep.ts

@@ -0,0 +1,114 @@
+/*
+ * 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 type of the metric group
+ */
+export const DependentMetricGroupRepKind = {
+  Funnel: "funnel",
+  Standard: "standard",
+} as const;
+/**
+ * The type of the metric group
+ */
+export type DependentMetricGroupRepKind = ClosedEnum<
+  typeof DependentMetricGroupRepKind
+>;
+
+export type DependentMetricGroupRep = {
+  /**
+   * A unique key to reference the metric group
+   */
+  key: string;
+  /**
+   * A human-friendly name for the metric group
+   */
+  name: string;
+  /**
+   * The type of the metric group
+   */
+  kind: DependentMetricGroupRepKind;
+  /**
+   * The location and content type of related resources
+   */
+  links: { [k: string]: Link };
+};
+
+/** @internal */
+export const DependentMetricGroupRepKind$inboundSchema: z.ZodNativeEnum<
+  typeof DependentMetricGroupRepKind
+> = z.nativeEnum(DependentMetricGroupRepKind);
+/** @internal */
+export const DependentMetricGroupRepKind$outboundSchema: z.ZodNativeEnum<
+  typeof DependentMetricGroupRepKind
+> = DependentMetricGroupRepKind$inboundSchema;
+
+/** @internal */
+export const DependentMetricGroupRep$inboundSchema: z.ZodType<
+  DependentMetricGroupRep,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+  kind: DependentMetricGroupRepKind$inboundSchema,
+  _links: z.record(Link$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "_links": "links",
+  });
+});
+/** @internal */
+export type DependentMetricGroupRep$Outbound = {
+  key: string;
+  name: string;
+  kind: string;
+  _links: { [k: string]: Link$Outbound };
+};
+
+/** @internal */
+export const DependentMetricGroupRep$outboundSchema: z.ZodType<
+  DependentMetricGroupRep$Outbound,
+  z.ZodTypeDef,
+  DependentMetricGroupRep
+> = z.object({
+  key: z.string(),
+  name: z.string(),
+  kind: DependentMetricGroupRepKind$outboundSchema,
+  links: z.record(Link$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    links: "_links",
+  });
+});
+
+export function dependentMetricGroupRepToJSON(
+  dependentMetricGroupRep: DependentMetricGroupRep,
+): string {
+  return JSON.stringify(
+    DependentMetricGroupRep$outboundSchema.parse(dependentMetricGroupRep),
+  );
+}
+export function dependentMetricGroupRepFromJSON(
+  jsonString: string,
+): SafeParseResult<DependentMetricGroupRep, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DependentMetricGroupRep$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DependentMetricGroupRep' from JSON`,
+  );
+}