@launchdarkly/mcp-server 0.3.1 → 0.4.0

package/bin/mcp-server.js

@@ -34236,9 +34236,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "2.0",
-    sdkVersion: "0.3.1",
-    genVersion: "2.618.0",
-    userAgent: "speakeasy-sdk/typescript 0.3.1 2.618.0 2.0 @launchdarkly/mcp-server"
+    sdkVersion: "0.4.0",
+    genVersion: "2.654.2",
+    userAgent: "speakeasy-sdk/typescript 0.4.0 2.654.2 2.0 @launchdarkly/mcp-server"
   };
 });
 
@@ -35217,24 +35217,53 @@ var init_tools = __esm(() => {
   init_shared();
 });
 
+// src/models/errors/launchdarklyerror.ts
+var LaunchDarklyError;
+var init_launchdarklyerror = __esm(() => {
+  LaunchDarklyError = class LaunchDarklyError extends Error {
+    statusCode;
+    body;
+    headers;
+    contentType;
+    rawResponse;
+    constructor(message, httpMeta) {
+      super(message);
+      this.statusCode = httpMeta.response.status;
+      this.body = httpMeta.body;
+      this.headers = httpMeta.response.headers;
+      this.contentType = httpMeta.response.headers.get("content-type") || "";
+      this.rawResponse = httpMeta.response;
+      this.name = "LaunchDarklyError";
+    }
+  };
+});
+
 // src/models/errors/apierror.ts
 var APIError;
 var init_apierror = __esm(() => {
-  APIError = class APIError extends Error {
-    rawResponse;
-    body;
-    statusCode;
-    contentType;
-    constructor(message, rawResponse, body = "") {
-      const statusCode = rawResponse.status;
-      const contentType2 = rawResponse.headers.get("content-type") || "";
-      const bodyString = body.length > 0 ? `
-${body}` : "";
-      super(`${message}: Status ${statusCode} Content-Type ${contentType2} Body ${bodyString}`);
-      this.rawResponse = rawResponse;
-      this.body = body;
-      this.statusCode = statusCode;
-      this.contentType = contentType2;
+  init_launchdarklyerror();
+  APIError = class APIError extends LaunchDarklyError {
+    constructor(message, httpMeta) {
+      if (message) {
+        message += `: `;
+      }
+      message += `Status ${httpMeta.response.status}`;
+      const contentType2 = httpMeta.response.headers.get("content-type") || `""`;
+      if (contentType2 !== "application/json") {
+        message += ` Content-Type ${contentType2.includes(" ") ? `"${contentType2}"` : contentType2}`;
+      }
+      const body = httpMeta.body || `""`;
+      message += body.length > 100 ? `
+` : ". ";
+      let bodyDisplay = body;
+      if (body.length > 1e4) {
+        const truncated = body.substring(0, 1e4);
+        const remaining = body.length - 1e4;
+        bodyDisplay = `${truncated}...and ${remaining} more chars`;
+      }
+      message += `Body: ${bodyDisplay}`;
+      message = message.trim();
+      super(message, httpMeta);
       this.name = "APIError";
     }
   };
@@ -35298,6 +35327,19 @@ var init_sdkvalidationerror = __esm(() => {
   SDKValidationError = class SDKValidationError extends Error {
     rawValue;
     rawMessage;
+    static [Symbol.hasInstance](instance) {
+      if (!(instance instanceof Error))
+        return false;
+      if (!("rawValue" in instance))
+        return false;
+      if (!("rawMessage" in instance))
+        return false;
+      if (!("pretty" in instance))
+        return false;
+      if (typeof instance.pretty !== "function")
+        return false;
+      return true;
+    }
     constructor(message, cause, rawValue) {
       super(`${message}: ${cause}`);
       this.name = "SDKValidationError";
@@ -35316,16 +35358,31 @@ ${formatZodError(this.cause)}`;
   };
 });
 
-// src/lib/schemas.ts
-function safeParse(rawValue, fn, errorMessage) {
-  try {
-    return OK2(fn(rawValue));
-  } catch (err) {
-    return ERR(new SDKValidationError(errorMessage, err, rawValue));
-  }
-}
-var init_schemas = __esm(() => {
+// src/models/errors/responsevalidationerror.ts
+var ResponseValidationError;
+var init_responsevalidationerror = __esm(() => {
+  init_esm();
+  init_launchdarklyerror();
   init_sdkvalidationerror();
+  ResponseValidationError = class ResponseValidationError extends LaunchDarklyError {
+    rawValue;
+    rawMessage;
+    constructor(message, extra) {
+      super(message, extra);
+      this.name = "ResponseValidationError";
+      this.cause = extra.cause;
+      this.rawValue = extra.rawValue;
+      this.rawMessage = extra.rawMessage;
+    }
+    pretty() {
+      if (this.cause instanceof ZodError) {
+        return `${this.rawMessage}
+${formatZodError(this.cause)}`;
+      } else {
+        return this.toString();
+      }
+    }
+  };
 });
 
 // src/lib/matchers.ts
@@ -35342,7 +35399,7 @@ function fail(codes) {
   return { enc: "fail", codes };
 }
 function match(...matchers) {
-  return async function matchFunc(response, options) {
+  return async function matchFunc(response, request, options) {
     let raw;
     let matcher;
     for (const match2 of matchers) {
@@ -35357,16 +35414,21 @@ function match(...matchers) {
       }
     }
     if (!matcher) {
-      const responseBody = await response.text();
       return [{
         ok: false,
-        error: new APIError("Unexpected API response status or content-type", response, responseBody)
-      }, responseBody];
+        error: new APIError("Unexpected Status or Content-Type", {
+          response,
+          request,
+          body: await response.text().catch(() => "")
+        })
+      }, raw];
     }
     const encoding = matcher.enc;
+    let body = "";
     switch (encoding) {
       case "json":
-        raw = await response.json();
+        body = await response.text();
+        raw = JSON.parse(body);
         break;
       case "jsonl":
         raw = response.body;
@@ -35378,16 +35440,19 @@ function match(...matchers) {
         raw = response.body;
         break;
       case "text":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       case "sse":
         raw = response.body;
         break;
       case "nil":
-        raw = await discardResponseBody(response);
+        body = await response.text();
+        raw = undefined;
         break;
       case "fail":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       default:
         throw new Error(`Unsupported response type: ${encoding}`);
@@ -35395,7 +35460,7 @@ function match(...matchers) {
     if (matcher.enc === "fail") {
       return [{
         ok: false,
-        error: new APIError("API error occurred", response, typeof raw === "string" ? raw : "")
+        error: new APIError("API error occurred", { request, response, body })
       }, raw];
     }
     const resultKey = matcher.key || options?.resultKey;
@@ -35404,7 +35469,10 @@ function match(...matchers) {
       data = {
         ...options?.extraFields,
         ...matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null,
-        ...isPlainObject(raw) ? raw : null
+        ...isPlainObject(raw) ? raw : null,
+        request$: request,
+        response$: response,
+        body$: body
       };
     } else if (resultKey) {
       data = {
@@ -35422,11 +35490,11 @@ function match(...matchers) {
       data = raw;
     }
     if ("err" in matcher) {
-      const result = safeParse(data, (v2) => matcher.schema.parse(v2), "Response validation failed");
+      const result = safeParseResponse(data, (v2) => matcher.schema.parse(v2), "Response validation failed", { request, response, body });
       return [result.ok ? { ok: false, error: result.value } : result, raw];
     } else {
       return [
-        safeParse(data, (v2) => matcher.schema.parse(v2), "Response validation failed"),
+        safeParseResponse(data, (v2) => matcher.schema.parse(v2), "Response validation failed", { request, response, body }),
         raw
       ];
     }
@@ -35439,26 +35507,23 @@ function unpackHeaders(headers) {
   }
   return out;
 }
-async function discardResponseBody(res) {
-  const reader = res.body?.getReader();
-  if (reader == null) {
-    return;
-  }
+function safeParseResponse(rawValue, fn, errorMessage, httpMeta) {
   try {
-    let done = false;
-    while (!done) {
-      const res2 = await reader.read();
-      done = res2.done;
-    }
-  } finally {
-    reader.releaseLock();
+    return OK2(fn(rawValue));
+  } catch (err) {
+    return ERR(new ResponseValidationError(errorMessage, {
+      cause: err,
+      rawValue,
+      rawMessage: errorMessage,
+      ...httpMeta
+    }));
   }
 }
 var DEFAULT_CONTENT_TYPES, headerValRE;
 var init_matchers = __esm(() => {
   init_apierror();
+  init_responsevalidationerror();
   init_http();
-  init_schemas();
   DEFAULT_CONTENT_TYPES = {
     jsonl: "application/jsonl",
     json: "application/json",
@@ -35499,6 +35564,18 @@ function compactMap(values) {
 }
 var init_primitives = () => {};
 
+// src/lib/schemas.ts
+function safeParse(rawValue, fn, errorMessage) {
+  try {
+    return OK2(fn(rawValue));
+  } catch (err) {
+    return ERR(new SDKValidationError(errorMessage, err, rawValue));
+  }
+}
+var init_schemas = __esm(() => {
+  init_sdkvalidationerror();
+});
+
 // src/lib/security.ts
 function resolveSecurity(...options) {
   const state = {
@@ -35821,12 +35898,12 @@ var init_aiconfigmaintainer = __esm(() => {
     MaintainerMember$.outboundSchema = MaintainerMember$outboundSchema;
   })(MaintainerMember$ ||= {});
   AIConfigMaintainer$inboundSchema = unionType([
-    lazyType(() => AiConfigsMaintainerTeam$inboundSchema),
-    lazyType(() => MaintainerMember$inboundSchema)
+    lazyType(() => MaintainerMember$inboundSchema),
+    lazyType(() => AiConfigsMaintainerTeam$inboundSchema)
   ]);
   AIConfigMaintainer$outboundSchema = unionType([
-    lazyType(() => AiConfigsMaintainerTeam$outboundSchema),
-    lazyType(() => MaintainerMember$outboundSchema)
+    lazyType(() => MaintainerMember$outboundSchema),
+    lazyType(() => AiConfigsMaintainerTeam$outboundSchema)
   ]);
   ((AIConfigMaintainer$) => {
     AIConfigMaintainer$.inboundSchema = AIConfigMaintainer$inboundSchema;
@@ -36052,8 +36129,11 @@ var init_aiconfigvariation = __esm(() => {
     _links: ParentLink$inboundSchema.optional(),
     color: stringType().optional(),
     comment: stringType().optional(),
+    description: stringType().optional(),
+    instructions: stringType().optional(),
     key: stringType(),
-    messages: arrayType(Message$inboundSchema),
+    _id: stringType(),
+    messages: arrayType(Message$inboundSchema).optional(),
     model: lazyType(() => AIConfigVariationModel$inboundSchema),
     modelConfigKey: stringType().optional(),
     name: stringType(),
@@ -36065,6 +36145,7 @@ var init_aiconfigvariation = __esm(() => {
   }).transform((v2) => {
     return remap(v2, {
       _links: "links",
+      _id: "id",
       _archivedAt: "archivedAt",
       _publishedAt: "publishedAt"
     });
@@ -36073,8 +36154,11 @@ var init_aiconfigvariation = __esm(() => {
     links: ParentLink$outboundSchema.optional(),
     color: stringType().optional(),
     comment: stringType().optional(),
+    description: stringType().optional(),
+    instructions: stringType().optional(),
     key: stringType(),
-    messages: arrayType(Message$outboundSchema),
+    id: stringType(),
+    messages: arrayType(Message$outboundSchema).optional(),
     model: lazyType(() => AIConfigVariationModel$outboundSchema),
     modelConfigKey: stringType().optional(),
     name: stringType(),
@@ -36086,6 +36170,7 @@ var init_aiconfigvariation = __esm(() => {
   }).transform((v2) => {
     return remap(v2, {
       links: "_links",
+      id: "_id",
       archivedAt: "_archivedAt",
       publishedAt: "_publishedAt"
     });
@@ -36116,7 +36201,7 @@ var init_parentandselflinks = __esm(() => {
 });
 
 // src/models/components/aiconfig.ts
-var AIConfig$inboundSchema, AIConfig$outboundSchema, AIConfig$;
+var AIConfigMode, AIConfigMode$inboundSchema, AIConfigMode$outboundSchema, AIConfigMode$, AIConfig$inboundSchema, AIConfig$outboundSchema, AIConfig$;
 var init_aiconfig = __esm(() => {
   init_esm();
   init_primitives();
@@ -36124,12 +36209,23 @@ var init_aiconfig = __esm(() => {
   init_aiconfigsaccess();
   init_aiconfigvariation();
   init_parentandselflinks();
+  AIConfigMode = {
+    Agent: "agent",
+    Completion: "completion"
+  };
+  AIConfigMode$inboundSchema = nativeEnumType(AIConfigMode);
+  AIConfigMode$outboundSchema = AIConfigMode$inboundSchema;
+  ((AIConfigMode$) => {
+    AIConfigMode$.inboundSchema = AIConfigMode$inboundSchema;
+    AIConfigMode$.outboundSchema = AIConfigMode$outboundSchema;
+  })(AIConfigMode$ ||= {});
   AIConfig$inboundSchema = objectType({
     _access: AiConfigsAccess$inboundSchema.optional(),
     _links: ParentAndSelfLinks$inboundSchema.optional(),
     description: stringType(),
     key: stringType(),
     _maintainer: AIConfigMaintainer$inboundSchema.optional(),
+    mode: AIConfigMode$inboundSchema.default("completion"),
     name: stringType(),
     tags: arrayType(stringType()),
     version: numberType().int(),
@@ -36149,6 +36245,7 @@ var init_aiconfig = __esm(() => {
     description: stringType(),
     key: stringType(),
     maintainer: AIConfigMaintainer$outboundSchema.optional(),
+    mode: AIConfigMode$outboundSchema.default("completion"),
     name: stringType(),
     tags: arrayType(stringType()),
     version: numberType().int(),
@@ -36193,14 +36290,25 @@ var init_aiconfigpatch = __esm(() => {
 });
 
 // src/models/components/aiconfigpost.ts
-var AIConfigPost$inboundSchema, AIConfigPost$outboundSchema, AIConfigPost$;
+var AIConfigPostMode, AIConfigPostMode$inboundSchema, AIConfigPostMode$outboundSchema, AIConfigPostMode$, AIConfigPost$inboundSchema, AIConfigPost$outboundSchema, AIConfigPost$;
 var init_aiconfigpost = __esm(() => {
   init_esm();
+  AIConfigPostMode = {
+    Agent: "agent",
+    Completion: "completion"
+  };
+  AIConfigPostMode$inboundSchema = nativeEnumType(AIConfigPostMode);
+  AIConfigPostMode$outboundSchema = AIConfigPostMode$inboundSchema;
+  ((AIConfigPostMode$) => {
+    AIConfigPostMode$.inboundSchema = AIConfigPostMode$inboundSchema;
+    AIConfigPostMode$.outboundSchema = AIConfigPostMode$outboundSchema;
+  })(AIConfigPostMode$ ||= {});
   AIConfigPost$inboundSchema = objectType({
     description: stringType().default(""),
     key: stringType(),
     maintainerId: stringType().optional(),
     maintainerTeamKey: stringType().optional(),
+    mode: AIConfigPostMode$inboundSchema.default("completion"),
     name: stringType(),
     tags: arrayType(stringType()).optional()
   });
@@ -36209,6 +36317,7 @@ var init_aiconfigpost = __esm(() => {
     key: stringType(),
     maintainerId: stringType().optional(),
     maintainerTeamKey: stringType().optional(),
+    mode: AIConfigPostMode$outboundSchema.default("completion"),
     name: stringType(),
     tags: arrayType(stringType()).optional()
   });
@@ -36248,48 +36357,749 @@ var init_paginatedlinks = __esm(() => {
     prev: AiConfigsLink$inboundSchema.optional(),
     self: AiConfigsLink$inboundSchema
   });
-  PaginatedLinks$outboundSchema = objectType({
-    first: AiConfigsLink$outboundSchema.optional(),
-    last: AiConfigsLink$outboundSchema.optional(),
-    next: AiConfigsLink$outboundSchema.optional(),
-    prev: AiConfigsLink$outboundSchema.optional(),
-    self: AiConfigsLink$outboundSchema
+  PaginatedLinks$outboundSchema = objectType({
+    first: AiConfigsLink$outboundSchema.optional(),
+    last: AiConfigsLink$outboundSchema.optional(),
+    next: AiConfigsLink$outboundSchema.optional(),
+    prev: AiConfigsLink$outboundSchema.optional(),
+    self: AiConfigsLink$outboundSchema
+  });
+  ((PaginatedLinks$) => {
+    PaginatedLinks$.inboundSchema = PaginatedLinks$inboundSchema;
+    PaginatedLinks$.outboundSchema = PaginatedLinks$outboundSchema;
+  })(PaginatedLinks$ ||= {});
+});
+
+// src/models/components/aiconfigs.ts
+var AIConfigs$inboundSchema, AIConfigs$outboundSchema, AIConfigs$;
+var init_aiconfigs = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_aiconfig();
+  init_paginatedlinks();
+  AIConfigs$inboundSchema = objectType({
+    _links: PaginatedLinks$inboundSchema.optional(),
+    items: arrayType(AIConfig$inboundSchema),
+    totalCount: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      _links: "links"
+    });
+  });
+  AIConfigs$outboundSchema = objectType({
+    links: PaginatedLinks$outboundSchema.optional(),
+    items: arrayType(AIConfig$outboundSchema),
+    totalCount: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      links: "_links"
+    });
+  });
+  ((AIConfigs$) => {
+    AIConfigs$.inboundSchema = AIConfigs$inboundSchema;
+    AIConfigs$.outboundSchema = AIConfigs$outboundSchema;
+  })(AIConfigs$ ||= {});
+});
+
+// src/models/components/aiconfigsexperimentenabledperiodrep.ts
+var AiConfigsExperimentEnabledPeriodRep$inboundSchema, AiConfigsExperimentEnabledPeriodRep$outboundSchema, AiConfigsExperimentEnabledPeriodRep$;
+var init_aiconfigsexperimentenabledperiodrep = __esm(() => {
+  init_esm();
+  AiConfigsExperimentEnabledPeriodRep$inboundSchema = objectType({
+    startDate: numberType().int().optional(),
+    stopDate: numberType().int().optional()
+  });
+  AiConfigsExperimentEnabledPeriodRep$outboundSchema = objectType({
+    startDate: numberType().int().optional(),
+    stopDate: numberType().int().optional()
+  });
+  ((AiConfigsExperimentEnabledPeriodRep$) => {
+    AiConfigsExperimentEnabledPeriodRep$.inboundSchema = AiConfigsExperimentEnabledPeriodRep$inboundSchema;
+    AiConfigsExperimentEnabledPeriodRep$.outboundSchema = AiConfigsExperimentEnabledPeriodRep$outboundSchema;
+  })(AiConfigsExperimentEnabledPeriodRep$ ||= {});
+});
+
+// src/models/components/aiconfigsexperimentenvironmentsettingrep.ts
+var AiConfigsExperimentEnvironmentSettingRep$inboundSchema, AiConfigsExperimentEnvironmentSettingRep$outboundSchema, AiConfigsExperimentEnvironmentSettingRep$;
+var init_aiconfigsexperimentenvironmentsettingrep = __esm(() => {
+  init_esm();
+  init_aiconfigsexperimentenabledperiodrep();
+  AiConfigsExperimentEnvironmentSettingRep$inboundSchema = objectType({
+    startDate: numberType().int().optional(),
+    stopDate: numberType().int().optional(),
+    enabledPeriods: arrayType(AiConfigsExperimentEnabledPeriodRep$inboundSchema).optional()
+  });
+  AiConfigsExperimentEnvironmentSettingRep$outboundSchema = objectType({
+    startDate: numberType().int().optional(),
+    stopDate: numberType().int().optional(),
+    enabledPeriods: arrayType(AiConfigsExperimentEnabledPeriodRep$outboundSchema).optional()
+  });
+  ((AiConfigsExperimentEnvironmentSettingRep$) => {
+    AiConfigsExperimentEnvironmentSettingRep$.inboundSchema = AiConfigsExperimentEnvironmentSettingRep$inboundSchema;
+    AiConfigsExperimentEnvironmentSettingRep$.outboundSchema = AiConfigsExperimentEnvironmentSettingRep$outboundSchema;
+  })(AiConfigsExperimentEnvironmentSettingRep$ ||= {});
+});
+
+// src/models/components/aiconfigsfilter.ts
+var AiConfigsFilterType, AiConfigsFilterType$inboundSchema, AiConfigsFilterType$outboundSchema, AiConfigsFilterType$, AiConfigsFilter$inboundSchema, AiConfigsFilter$outboundSchema, AiConfigsFilter$;
+var init_aiconfigsfilter = __esm(() => {
+  init_esm();
+  AiConfigsFilterType = {
+    Group: "group",
+    ContextAttribute: "contextAttribute",
+    EventProperty: "eventProperty"
+  };
+  AiConfigsFilterType$inboundSchema = nativeEnumType(AiConfigsFilterType);
+  AiConfigsFilterType$outboundSchema = AiConfigsFilterType$inboundSchema;
+  ((AiConfigsFilterType$) => {
+    AiConfigsFilterType$.inboundSchema = AiConfigsFilterType$inboundSchema;
+    AiConfigsFilterType$.outboundSchema = AiConfigsFilterType$outboundSchema;
+  })(AiConfigsFilterType$ ||= {});
+  AiConfigsFilter$inboundSchema = objectType({
+    type: AiConfigsFilterType$inboundSchema,
+    attribute: stringType().optional(),
+    op: stringType(),
+    values: arrayType(anyType()),
+    contextKind: stringType().optional(),
+    negate: booleanType()
+  });
+  AiConfigsFilter$outboundSchema = objectType({
+    type: AiConfigsFilterType$outboundSchema,
+    attribute: stringType().optional(),
+    op: stringType(),
+    values: arrayType(anyType()),
+    contextKind: stringType().optional(),
+    negate: booleanType()
+  });
+  ((AiConfigsFilter$) => {
+    AiConfigsFilter$.inboundSchema = AiConfigsFilter$inboundSchema;
+    AiConfigsFilter$.outboundSchema = AiConfigsFilter$outboundSchema;
+  })(AiConfigsFilter$ ||= {});
+});
+
+// src/models/components/aiconfigsmembersummary.ts
+var AiConfigsMemberSummary$inboundSchema, AiConfigsMemberSummary$outboundSchema, AiConfigsMemberSummary$;
+var init_aiconfigsmembersummary = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_aiconfigslink();
+  AiConfigsMemberSummary$inboundSchema = objectType({
+    _links: recordType(AiConfigsLink$inboundSchema),
+    _id: stringType(),
+    firstName: stringType().optional(),
+    lastName: stringType().optional(),
+    role: stringType(),
+    email: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      _links: "links",
+      _id: "id"
+    });
+  });
+  AiConfigsMemberSummary$outboundSchema = objectType({
+    links: recordType(AiConfigsLink$outboundSchema),
+    id: stringType(),
+    firstName: stringType().optional(),
+    lastName: stringType().optional(),
+    role: stringType(),
+    email: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      links: "_links",
+      id: "_id"
+    });
+  });
+  ((AiConfigsMemberSummary$) => {
+    AiConfigsMemberSummary$.inboundSchema = AiConfigsMemberSummary$inboundSchema;
+    AiConfigsMemberSummary$.outboundSchema = AiConfigsMemberSummary$outboundSchema;
+  })(AiConfigsMemberSummary$ ||= {});
+});
+
+// src/models/components/aiconfigsmetriceventdefaultrep.ts
+var AiConfigsMetricEventDefaultRep$inboundSchema, AiConfigsMetricEventDefaultRep$outboundSchema, AiConfigsMetricEventDefaultRep$;
+var init_aiconfigsmetriceventdefaultrep = __esm(() => {
+  init_esm();
+  AiConfigsMetricEventDefaultRep$inboundSchema = objectType({
+    disabled: booleanType().optional(),
+    value: numberType().optional()
+  });
+  AiConfigsMetricEventDefaultRep$outboundSchema = objectType({
+    disabled: booleanType().optional(),
+    value: numberType().optional()
+  });
+  ((AiConfigsMetricEventDefaultRep$) => {
+    AiConfigsMetricEventDefaultRep$.inboundSchema = AiConfigsMetricEventDefaultRep$inboundSchema;
+    AiConfigsMetricEventDefaultRep$.outboundSchema = AiConfigsMetricEventDefaultRep$outboundSchema;
+  })(AiConfigsMetricEventDefaultRep$ ||= {});
+});
+
+// src/models/components/aiconfigsmodification.ts
+var AiConfigsModification$inboundSchema, AiConfigsModification$outboundSchema, AiConfigsModification$;
+var init_aiconfigsmodification = __esm(() => {
+  init_esm();
+  AiConfigsModification$inboundSchema = objectType({
+    date: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional()
+  });
+  AiConfigsModification$outboundSchema = objectType({
+    date: dateType().transform((v2) => v2.toISOString()).optional()
+  });
+  ((AiConfigsModification$) => {
+    AiConfigsModification$.inboundSchema = AiConfigsModification$inboundSchema;
+    AiConfigsModification$.outboundSchema = AiConfigsModification$outboundSchema;
+  })(AiConfigsModification$ ||= {});
+});
+
+// src/models/components/aiconfigsmetriclistingrep.ts
+var AiConfigsMetricListingRepKind, AiConfigsMetricListingRepSuccessCriteria, AiConfigsMetricListingRepUnitAggregationType, AiConfigsMetricListingRepAnalysisType, AiConfigsMetricListingRepKind$inboundSchema, AiConfigsMetricListingRepKind$outboundSchema, AiConfigsMetricListingRepKind$, AiConfigsMetricListingRepSuccessCriteria$inboundSchema, AiConfigsMetricListingRepSuccessCriteria$outboundSchema, AiConfigsMetricListingRepSuccessCriteria$, AiConfigsMetricListingRepUnitAggregationType$inboundSchema, AiConfigsMetricListingRepUnitAggregationType$outboundSchema, AiConfigsMetricListingRepUnitAggregationType$, AiConfigsMetricListingRepAnalysisType$inboundSchema, AiConfigsMetricListingRepAnalysisType$outboundSchema, AiConfigsMetricListingRepAnalysisType$, AiConfigsMetricListingRep$inboundSchema, AiConfigsMetricListingRep$outboundSchema, AiConfigsMetricListingRep$;
+var init_aiconfigsmetriclistingrep = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_aiconfigsaccess();
+  init_aiconfigsfilter();
+  init_aiconfigslink();
+  init_aiconfigsmembersummary();
+  init_aiconfigsmetriceventdefaultrep();
+  init_aiconfigsmodification();
+  AiConfigsMetricListingRepKind = {
+    Pageview: "pageview",
+    Click: "click",
+    Custom: "custom"
+  };
+  AiConfigsMetricListingRepSuccessCriteria = {
+    HigherThanBaseline: "HigherThanBaseline",
+    LowerThanBaseline: "LowerThanBaseline"
+  };
+  AiConfigsMetricListingRepUnitAggregationType = {
+    Average: "average",
+    Sum: "sum"
+  };
+  AiConfigsMetricListingRepAnalysisType = {
+    Mean: "mean",
+    Percentile: "percentile"
+  };
+  AiConfigsMetricListingRepKind$inboundSchema = nativeEnumType(AiConfigsMetricListingRepKind);
+  AiConfigsMetricListingRepKind$outboundSchema = AiConfigsMetricListingRepKind$inboundSchema;
+  ((AiConfigsMetricListingRepKind$) => {
+    AiConfigsMetricListingRepKind$.inboundSchema = AiConfigsMetricListingRepKind$inboundSchema;
+    AiConfigsMetricListingRepKind$.outboundSchema = AiConfigsMetricListingRepKind$outboundSchema;
+  })(AiConfigsMetricListingRepKind$ ||= {});
+  AiConfigsMetricListingRepSuccessCriteria$inboundSchema = nativeEnumType(AiConfigsMetricListingRepSuccessCriteria);
+  AiConfigsMetricListingRepSuccessCriteria$outboundSchema = AiConfigsMetricListingRepSuccessCriteria$inboundSchema;
+  ((AiConfigsMetricListingRepSuccessCriteria$) => {
+    AiConfigsMetricListingRepSuccessCriteria$.inboundSchema = AiConfigsMetricListingRepSuccessCriteria$inboundSchema;
+    AiConfigsMetricListingRepSuccessCriteria$.outboundSchema = AiConfigsMetricListingRepSuccessCriteria$outboundSchema;
+  })(AiConfigsMetricListingRepSuccessCriteria$ ||= {});
+  AiConfigsMetricListingRepUnitAggregationType$inboundSchema = nativeEnumType(AiConfigsMetricListingRepUnitAggregationType);
+  AiConfigsMetricListingRepUnitAggregationType$outboundSchema = AiConfigsMetricListingRepUnitAggregationType$inboundSchema;
+  ((AiConfigsMetricListingRepUnitAggregationType$) => {
+    AiConfigsMetricListingRepUnitAggregationType$.inboundSchema = AiConfigsMetricListingRepUnitAggregationType$inboundSchema;
+    AiConfigsMetricListingRepUnitAggregationType$.outboundSchema = AiConfigsMetricListingRepUnitAggregationType$outboundSchema;
+  })(AiConfigsMetricListingRepUnitAggregationType$ ||= {});
+  AiConfigsMetricListingRepAnalysisType$inboundSchema = nativeEnumType(AiConfigsMetricListingRepAnalysisType);
+  AiConfigsMetricListingRepAnalysisType$outboundSchema = AiConfigsMetricListingRepAnalysisType$inboundSchema;
+  ((AiConfigsMetricListingRepAnalysisType$) => {
+    AiConfigsMetricListingRepAnalysisType$.inboundSchema = AiConfigsMetricListingRepAnalysisType$inboundSchema;
+    AiConfigsMetricListingRepAnalysisType$.outboundSchema = AiConfigsMetricListingRepAnalysisType$outboundSchema;
+  })(AiConfigsMetricListingRepAnalysisType$ ||= {});
+  AiConfigsMetricListingRep$inboundSchema = objectType({
+    experimentCount: numberType().int().optional(),
+    metricGroupCount: numberType().int().optional(),
+    guardedRolloutCount: numberType().int().optional(),
+    _id: stringType(),
+    _versionId: stringType(),
+    key: stringType(),
+    name: stringType(),
+    kind: AiConfigsMetricListingRepKind$inboundSchema,
+    _attachedFlagCount: numberType().int().optional(),
+    _links: recordType(AiConfigsLink$inboundSchema),
+    _site: AiConfigsLink$inboundSchema.optional(),
+    _access: AiConfigsAccess$inboundSchema.optional(),
+    tags: arrayType(stringType()),
+    _creationDate: numberType().int(),
+    lastModified: AiConfigsModification$inboundSchema.optional(),
+    maintainerId: stringType().optional(),
+    _maintainer: AiConfigsMemberSummary$inboundSchema.optional(),
+    description: stringType().optional(),
+    category: stringType().optional(),
+    isNumeric: booleanType().optional(),
+    successCriteria: AiConfigsMetricListingRepSuccessCriteria$inboundSchema.optional(),
+    unit: stringType().optional(),
+    eventKey: stringType().optional(),
+    randomizationUnits: arrayType(stringType()).optional(),
+    filters: AiConfigsFilter$inboundSchema.optional(),
+    unitAggregationType: AiConfigsMetricListingRepUnitAggregationType$inboundSchema.optional(),
+    analysisType: AiConfigsMetricListingRepAnalysisType$inboundSchema.optional(),
+    percentileValue: numberType().int().optional(),
+    eventDefault: AiConfigsMetricEventDefaultRep$inboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      _id: "id",
+      _versionId: "versionId",
+      _attachedFlagCount: "attachedFlagCount",
+      _links: "links",
+      _site: "site",
+      _access: "access",
+      _creationDate: "creationDate",
+      _maintainer: "maintainer"
+    });
+  });
+  AiConfigsMetricListingRep$outboundSchema = objectType({
+    experimentCount: numberType().int().optional(),
+    metricGroupCount: numberType().int().optional(),
+    guardedRolloutCount: numberType().int().optional(),
+    id: stringType(),
+    versionId: stringType(),
+    key: stringType(),
+    name: stringType(),
+    kind: AiConfigsMetricListingRepKind$outboundSchema,
+    attachedFlagCount: numberType().int().optional(),
+    links: recordType(AiConfigsLink$outboundSchema),
+    site: AiConfigsLink$outboundSchema.optional(),
+    access: AiConfigsAccess$outboundSchema.optional(),
+    tags: arrayType(stringType()),
+    creationDate: numberType().int(),
+    lastModified: AiConfigsModification$outboundSchema.optional(),
+    maintainerId: stringType().optional(),
+    maintainer: AiConfigsMemberSummary$outboundSchema.optional(),
+    description: stringType().optional(),
+    category: stringType().optional(),
+    isNumeric: booleanType().optional(),
+    successCriteria: AiConfigsMetricListingRepSuccessCriteria$outboundSchema.optional(),
+    unit: stringType().optional(),
+    eventKey: stringType().optional(),
+    randomizationUnits: arrayType(stringType()).optional(),
+    filters: AiConfigsFilter$outboundSchema.optional(),
+    unitAggregationType: AiConfigsMetricListingRepUnitAggregationType$outboundSchema.optional(),
+    analysisType: AiConfigsMetricListingRepAnalysisType$outboundSchema.optional(),
+    percentileValue: numberType().int().optional(),
+    eventDefault: AiConfigsMetricEventDefaultRep$outboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      id: "_id",
+      versionId: "_versionId",
+      attachedFlagCount: "_attachedFlagCount",
+      links: "_links",
+      site: "_site",
+      access: "_access",
+      creationDate: "_creationDate",
+      maintainer: "_maintainer"
+    });
+  });
+  ((AiConfigsMetricListingRep$) => {
+    AiConfigsMetricListingRep$.inboundSchema = AiConfigsMetricListingRep$inboundSchema;
+    AiConfigsMetricListingRep$.outboundSchema = AiConfigsMetricListingRep$outboundSchema;
+  })(AiConfigsMetricListingRep$ ||= {});
+});
+
+// src/models/components/aiconfigslegacyexperimentrep.ts
+var AiConfigsLegacyExperimentRep$inboundSchema, AiConfigsLegacyExperimentRep$outboundSchema, AiConfigsLegacyExperimentRep$;
+var init_aiconfigslegacyexperimentrep = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_aiconfigsexperimentenvironmentsettingrep();
+  init_aiconfigsmetriclistingrep();
+  AiConfigsLegacyExperimentRep$inboundSchema = objectType({
+    metricKey: stringType().optional(),
+    _metric: AiConfigsMetricListingRep$inboundSchema.optional(),
+    environments: arrayType(stringType()).optional(),
+    _environmentSettings: recordType(AiConfigsExperimentEnvironmentSettingRep$inboundSchema).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      _metric: "metric",
+      _environmentSettings: "environmentSettings"
+    });
+  });
+  AiConfigsLegacyExperimentRep$outboundSchema = objectType({
+    metricKey: stringType().optional(),
+    metric: AiConfigsMetricListingRep$outboundSchema.optional(),
+    environments: arrayType(stringType()).optional(),
+    environmentSettings: recordType(AiConfigsExperimentEnvironmentSettingRep$outboundSchema).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      metric: "_metric",
+      environmentSettings: "_environmentSettings"
+    });
+  });
+  ((AiConfigsLegacyExperimentRep$) => {
+    AiConfigsLegacyExperimentRep$.inboundSchema = AiConfigsLegacyExperimentRep$inboundSchema;
+    AiConfigsLegacyExperimentRep$.outboundSchema = AiConfigsLegacyExperimentRep$outboundSchema;
+  })(AiConfigsLegacyExperimentRep$ ||= {});
+});
+
+// src/models/components/aiconfigsexperimentinforep.ts
+var AiConfigsExperimentInfoRep$inboundSchema, AiConfigsExperimentInfoRep$outboundSchema, AiConfigsExperimentInfoRep$;
+var init_aiconfigsexperimentinforep = __esm(() => {
+  init_esm();
+  init_aiconfigslegacyexperimentrep();
+  AiConfigsExperimentInfoRep$inboundSchema = objectType({
+    baselineIdx: numberType().int(),
+    items: arrayType(AiConfigsLegacyExperimentRep$inboundSchema)
+  });
+  AiConfigsExperimentInfoRep$outboundSchema = objectType({
+    baselineIdx: numberType().int(),
+    items: arrayType(AiConfigsLegacyExperimentRep$outboundSchema)
+  });
+  ((AiConfigsExperimentInfoRep$) => {
+    AiConfigsExperimentInfoRep$.inboundSchema = AiConfigsExperimentInfoRep$inboundSchema;
+    AiConfigsExperimentInfoRep$.outboundSchema = AiConfigsExperimentInfoRep$outboundSchema;
+  })(AiConfigsExperimentInfoRep$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingdefaults.ts
+var AIConfigTargetingDefaults$inboundSchema, AIConfigTargetingDefaults$outboundSchema, AIConfigTargetingDefaults$;
+var init_aiconfigtargetingdefaults = __esm(() => {
+  init_esm();
+  AIConfigTargetingDefaults$inboundSchema = objectType({
+    onVariation: numberType().int(),
+    offVariation: numberType().int()
+  });
+  AIConfigTargetingDefaults$outboundSchema = objectType({
+    onVariation: numberType().int(),
+    offVariation: numberType().int()
+  });
+  ((AIConfigTargetingDefaults$) => {
+    AIConfigTargetingDefaults$.inboundSchema = AIConfigTargetingDefaults$inboundSchema;
+    AIConfigTargetingDefaults$.outboundSchema = AIConfigTargetingDefaults$outboundSchema;
+  })(AIConfigTargetingDefaults$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingenvironmentfallthroughrolloutexperimentationallocation.ts
+var AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$inboundSchema, AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$outboundSchema, AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$;
+var init_aiconfigtargetingenvironmentfallthroughrolloutexperimentationallocation = __esm(() => {
+  init_esm();
+  AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$inboundSchema = objectType({
+    canReshuffle: booleanType(),
+    defaultVariation: numberType().int(),
+    type: stringType()
+  });
+  AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$outboundSchema = objectType({
+    canReshuffle: booleanType(),
+    defaultVariation: numberType().int(),
+    type: stringType()
+  });
+  ((AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$) => {
+    AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$.inboundSchema = AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$inboundSchema;
+    AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$.outboundSchema = AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$outboundSchema;
+  })(AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingenvironmentfallthroughrolloutvariation.ts
+var AIConfigTargetingEnvironmentFallthroughRolloutVariation$inboundSchema, AIConfigTargetingEnvironmentFallthroughRolloutVariation$outboundSchema, AIConfigTargetingEnvironmentFallthroughRolloutVariation$;
+var init_aiconfigtargetingenvironmentfallthroughrolloutvariation = __esm(() => {
+  init_esm();
+  init_primitives();
+  AIConfigTargetingEnvironmentFallthroughRolloutVariation$inboundSchema = objectType({
+    _untracked: booleanType().optional(),
+    variation: numberType().int(),
+    weight: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      _untracked: "untracked"
+    });
+  });
+  AIConfigTargetingEnvironmentFallthroughRolloutVariation$outboundSchema = objectType({
+    untracked: booleanType().optional(),
+    variation: numberType().int(),
+    weight: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      untracked: "_untracked"
+    });
+  });
+  ((AIConfigTargetingEnvironmentFallthroughRolloutVariation$) => {
+    AIConfigTargetingEnvironmentFallthroughRolloutVariation$.inboundSchema = AIConfigTargetingEnvironmentFallthroughRolloutVariation$inboundSchema;
+    AIConfigTargetingEnvironmentFallthroughRolloutVariation$.outboundSchema = AIConfigTargetingEnvironmentFallthroughRolloutVariation$outboundSchema;
+  })(AIConfigTargetingEnvironmentFallthroughRolloutVariation$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingenvironmentfallthroughrollout.ts
+var AIConfigTargetingEnvironmentFallthroughRollout$inboundSchema, AIConfigTargetingEnvironmentFallthroughRollout$outboundSchema, AIConfigTargetingEnvironmentFallthroughRollout$;
+var init_aiconfigtargetingenvironmentfallthroughrollout = __esm(() => {
+  init_esm();
+  init_aiconfigtargetingenvironmentfallthroughrolloutexperimentationallocation();
+  init_aiconfigtargetingenvironmentfallthroughrolloutvariation();
+  AIConfigTargetingEnvironmentFallthroughRollout$inboundSchema = objectType({
+    bucketBy: stringType().optional(),
+    contextKind: stringType(),
+    experimentAllocation: AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$inboundSchema.optional(),
+    seed: numberType().int().optional(),
+    variations: arrayType(AIConfigTargetingEnvironmentFallthroughRolloutVariation$inboundSchema)
+  });
+  AIConfigTargetingEnvironmentFallthroughRollout$outboundSchema = objectType({
+    bucketBy: stringType().optional(),
+    contextKind: stringType(),
+    experimentAllocation: AIConfigTargetingEnvironmentFallthroughRolloutExperimentationAllocation$outboundSchema.optional(),
+    seed: numberType().int().optional(),
+    variations: arrayType(AIConfigTargetingEnvironmentFallthroughRolloutVariation$outboundSchema)
+  });
+  ((AIConfigTargetingEnvironmentFallthroughRollout$) => {
+    AIConfigTargetingEnvironmentFallthroughRollout$.inboundSchema = AIConfigTargetingEnvironmentFallthroughRollout$inboundSchema;
+    AIConfigTargetingEnvironmentFallthroughRollout$.outboundSchema = AIConfigTargetingEnvironmentFallthroughRollout$outboundSchema;
+  })(AIConfigTargetingEnvironmentFallthroughRollout$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingenvironmentfallthrough.ts
+var AIConfigTargetingEnvironmentFallthrough$inboundSchema, AIConfigTargetingEnvironmentFallthrough$outboundSchema, AIConfigTargetingEnvironmentFallthrough$;
+var init_aiconfigtargetingenvironmentfallthrough = __esm(() => {
+  init_esm();
+  init_aiconfigtargetingenvironmentfallthroughrollout();
+  AIConfigTargetingEnvironmentFallthrough$inboundSchema = objectType({
+    variation: numberType().int().optional(),
+    rollout: AIConfigTargetingEnvironmentFallthroughRollout$inboundSchema.optional()
+  });
+  AIConfigTargetingEnvironmentFallthrough$outboundSchema = objectType({
+    variation: numberType().int().optional(),
+    rollout: AIConfigTargetingEnvironmentFallthroughRollout$outboundSchema.optional()
+  });
+  ((AIConfigTargetingEnvironmentFallthrough$) => {
+    AIConfigTargetingEnvironmentFallthrough$.inboundSchema = AIConfigTargetingEnvironmentFallthrough$inboundSchema;
+    AIConfigTargetingEnvironmentFallthrough$.outboundSchema = AIConfigTargetingEnvironmentFallthrough$outboundSchema;
+  })(AIConfigTargetingEnvironmentFallthrough$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingenvironmentruleclause.ts
+var AIConfigTargetingEnvironmentRuleClause$inboundSchema, AIConfigTargetingEnvironmentRuleClause$outboundSchema, AIConfigTargetingEnvironmentRuleClause$;
+var init_aiconfigtargetingenvironmentruleclause = __esm(() => {
+  init_esm();
+  AIConfigTargetingEnvironmentRuleClause$inboundSchema = objectType({
+    attribute: stringType(),
+    id: stringType(),
+    negate: booleanType(),
+    op: stringType(),
+    values: arrayType(anyType())
+  });
+  AIConfigTargetingEnvironmentRuleClause$outboundSchema = objectType({
+    attribute: stringType(),
+    id: stringType(),
+    negate: booleanType(),
+    op: stringType(),
+    values: arrayType(anyType())
+  });
+  ((AIConfigTargetingEnvironmentRuleClause$) => {
+    AIConfigTargetingEnvironmentRuleClause$.inboundSchema = AIConfigTargetingEnvironmentRuleClause$inboundSchema;
+    AIConfigTargetingEnvironmentRuleClause$.outboundSchema = AIConfigTargetingEnvironmentRuleClause$outboundSchema;
+  })(AIConfigTargetingEnvironmentRuleClause$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingenvironmentrule.ts
+var AIConfigTargetingEnvironmentRule$inboundSchema, AIConfigTargetingEnvironmentRule$outboundSchema, AIConfigTargetingEnvironmentRule$;
+var init_aiconfigtargetingenvironmentrule = __esm(() => {
+  init_esm();
+  init_aiconfigtargetingenvironmentruleclause();
+  AIConfigTargetingEnvironmentRule$inboundSchema = objectType({
+    clauses: arrayType(AIConfigTargetingEnvironmentRuleClause$inboundSchema),
+    trackEvents: booleanType()
+  });
+  AIConfigTargetingEnvironmentRule$outboundSchema = objectType({
+    clauses: arrayType(AIConfigTargetingEnvironmentRuleClause$outboundSchema),
+    trackEvents: booleanType()
+  });
+  ((AIConfigTargetingEnvironmentRule$) => {
+    AIConfigTargetingEnvironmentRule$.inboundSchema = AIConfigTargetingEnvironmentRule$inboundSchema;
+    AIConfigTargetingEnvironmentRule$.outboundSchema = AIConfigTargetingEnvironmentRule$outboundSchema;
+  })(AIConfigTargetingEnvironmentRule$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingenvironmenttarget.ts
+var AIConfigTargetingEnvironmentTarget$inboundSchema, AIConfigTargetingEnvironmentTarget$outboundSchema, AIConfigTargetingEnvironmentTarget$;
+var init_aiconfigtargetingenvironmenttarget = __esm(() => {
+  init_esm();
+  AIConfigTargetingEnvironmentTarget$inboundSchema = objectType({
+    contextKind: stringType(),
+    values: arrayType(stringType()),
+    variation: numberType().int()
+  });
+  AIConfigTargetingEnvironmentTarget$outboundSchema = objectType({
+    contextKind: stringType(),
+    values: arrayType(stringType()),
+    variation: numberType().int()
+  });
+  ((AIConfigTargetingEnvironmentTarget$) => {
+    AIConfigTargetingEnvironmentTarget$.inboundSchema = AIConfigTargetingEnvironmentTarget$inboundSchema;
+    AIConfigTargetingEnvironmentTarget$.outboundSchema = AIConfigTargetingEnvironmentTarget$outboundSchema;
+  })(AIConfigTargetingEnvironmentTarget$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingenvironment.ts
+var AIConfigTargetingEnvironment$inboundSchema, AIConfigTargetingEnvironment$outboundSchema, AIConfigTargetingEnvironment$;
+var init_aiconfigtargetingenvironment = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_aiconfigtargetingenvironmentfallthrough();
+  init_aiconfigtargetingenvironmentrule();
+  init_aiconfigtargetingenvironmenttarget();
+  AIConfigTargetingEnvironment$inboundSchema = objectType({
+    contextTargets: arrayType(AIConfigTargetingEnvironmentTarget$inboundSchema),
+    enabled: booleanType(),
+    fallthrough: AIConfigTargetingEnvironmentFallthrough$inboundSchema,
+    lastModified: numberType().int(),
+    offVariation: numberType().int().optional(),
+    rules: arrayType(AIConfigTargetingEnvironmentRule$inboundSchema),
+    targets: arrayType(AIConfigTargetingEnvironmentTarget$inboundSchema),
+    trackEvents: booleanType(),
+    trackEventsFallthrough: booleanType(),
+    _environmentName: stringType(),
+    _version: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      _environmentName: "environmentName",
+      _version: "version"
+    });
+  });
+  AIConfigTargetingEnvironment$outboundSchema = objectType({
+    contextTargets: arrayType(AIConfigTargetingEnvironmentTarget$outboundSchema),
+    enabled: booleanType(),
+    fallthrough: AIConfigTargetingEnvironmentFallthrough$outboundSchema,
+    lastModified: numberType().int(),
+    offVariation: numberType().int().optional(),
+    rules: arrayType(AIConfigTargetingEnvironmentRule$outboundSchema),
+    targets: arrayType(AIConfigTargetingEnvironmentTarget$outboundSchema),
+    trackEvents: booleanType(),
+    trackEventsFallthrough: booleanType(),
+    environmentName: stringType(),
+    version: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      environmentName: "_environmentName",
+      version: "_version"
+    });
+  });
+  ((AIConfigTargetingEnvironment$) => {
+    AIConfigTargetingEnvironment$.inboundSchema = AIConfigTargetingEnvironment$inboundSchema;
+    AIConfigTargetingEnvironment$.outboundSchema = AIConfigTargetingEnvironment$outboundSchema;
+  })(AIConfigTargetingEnvironment$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingvariationjson.ts
+var AIConfigTargetingVariationJSON$inboundSchema, AIConfigTargetingVariationJSON$outboundSchema, AIConfigTargetingVariationJSON$;
+var init_aiconfigtargetingvariationjson = __esm(() => {
+  init_esm();
+  AIConfigTargetingVariationJSON$inboundSchema = objectType({});
+  AIConfigTargetingVariationJSON$outboundSchema = objectType({});
+  ((AIConfigTargetingVariationJSON$) => {
+    AIConfigTargetingVariationJSON$.inboundSchema = AIConfigTargetingVariationJSON$inboundSchema;
+    AIConfigTargetingVariationJSON$.outboundSchema = AIConfigTargetingVariationJSON$outboundSchema;
+  })(AIConfigTargetingVariationJSON$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingvariationvalue.ts
+var AIConfigTargetingVariationValue$inboundSchema, AIConfigTargetingVariationValue$outboundSchema, AIConfigTargetingVariationValue$;
+var init_aiconfigtargetingvariationvalue = __esm(() => {
+  init_esm();
+  init_aiconfigtargetingvariationjson();
+  AIConfigTargetingVariationValue$inboundSchema = unionType([
+    AIConfigTargetingVariationJSON$inboundSchema,
+    booleanType(),
+    numberType(),
+    stringType()
+  ]);
+  AIConfigTargetingVariationValue$outboundSchema = unionType([
+    AIConfigTargetingVariationJSON$outboundSchema,
+    booleanType(),
+    numberType(),
+    stringType()
+  ]);
+  ((AIConfigTargetingVariationValue$) => {
+    AIConfigTargetingVariationValue$.inboundSchema = AIConfigTargetingVariationValue$inboundSchema;
+    AIConfigTargetingVariationValue$.outboundSchema = AIConfigTargetingVariationValue$outboundSchema;
+  })(AIConfigTargetingVariationValue$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingvariation.ts
+var AIConfigTargetingVariation$inboundSchema, AIConfigTargetingVariation$outboundSchema, AIConfigTargetingVariation$;
+var init_aiconfigtargetingvariation = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_aiconfigtargetingvariationvalue();
+  AIConfigTargetingVariation$inboundSchema = objectType({
+    _id: stringType(),
+    description: stringType(),
+    name: stringType(),
+    value: AIConfigTargetingVariationValue$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      _id: "id"
+    });
+  });
+  AIConfigTargetingVariation$outboundSchema = objectType({
+    id: stringType(),
+    description: stringType(),
+    name: stringType(),
+    value: AIConfigTargetingVariationValue$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      id: "_id"
+    });
   });
-  ((PaginatedLinks$) => {
-    PaginatedLinks$.inboundSchema = PaginatedLinks$inboundSchema;
-    PaginatedLinks$.outboundSchema = PaginatedLinks$outboundSchema;
-  })(PaginatedLinks$ ||= {});
+  ((AIConfigTargetingVariation$) => {
+    AIConfigTargetingVariation$.inboundSchema = AIConfigTargetingVariation$inboundSchema;
+    AIConfigTargetingVariation$.outboundSchema = AIConfigTargetingVariation$outboundSchema;
+  })(AIConfigTargetingVariation$ ||= {});
 });
 
-// src/models/components/aiconfigs.ts
-var AIConfigs$inboundSchema, AIConfigs$outboundSchema, AIConfigs$;
-var init_aiconfigs = __esm(() => {
+// src/models/components/aiconfigtargeting.ts
+var AIConfigTargeting$inboundSchema, AIConfigTargeting$outboundSchema, AIConfigTargeting$;
+var init_aiconfigtargeting = __esm(() => {
   init_esm();
   init_primitives();
-  init_aiconfig();
-  init_paginatedlinks();
-  AIConfigs$inboundSchema = objectType({
-    _links: PaginatedLinks$inboundSchema.optional(),
-    items: arrayType(AIConfig$inboundSchema),
-    totalCount: numberType().int()
+  init_aiconfigsexperimentinforep();
+  init_aiconfigtargetingdefaults();
+  init_aiconfigtargetingenvironment();
+  init_aiconfigtargetingvariation();
+  AIConfigTargeting$inboundSchema = objectType({
+    createdAt: numberType().int(),
+    defaults: AIConfigTargetingDefaults$inboundSchema.optional(),
+    environments: recordType(AIConfigTargetingEnvironment$inboundSchema),
+    experiments: AiConfigsExperimentInfoRep$inboundSchema,
+    key: stringType(),
+    name: stringType(),
+    tags: arrayType(stringType()),
+    variations: arrayType(AIConfigTargetingVariation$inboundSchema),
+    _version: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
-      _links: "links"
+      _version: "version"
     });
   });
-  AIConfigs$outboundSchema = objectType({
-    links: PaginatedLinks$outboundSchema.optional(),
-    items: arrayType(AIConfig$outboundSchema),
-    totalCount: numberType().int()
+  AIConfigTargeting$outboundSchema = objectType({
+    createdAt: numberType().int(),
+    defaults: AIConfigTargetingDefaults$outboundSchema.optional(),
+    environments: recordType(AIConfigTargetingEnvironment$outboundSchema),
+    experiments: AiConfigsExperimentInfoRep$outboundSchema,
+    key: stringType(),
+    name: stringType(),
+    tags: arrayType(stringType()),
+    variations: arrayType(AIConfigTargetingVariation$outboundSchema),
+    version: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
-      links: "_links"
+      version: "_version"
     });
   });
-  ((AIConfigs$) => {
-    AIConfigs$.inboundSchema = AIConfigs$inboundSchema;
-    AIConfigs$.outboundSchema = AIConfigs$outboundSchema;
-  })(AIConfigs$ ||= {});
+  ((AIConfigTargeting$) => {
+    AIConfigTargeting$.inboundSchema = AIConfigTargeting$inboundSchema;
+    AIConfigTargeting$.outboundSchema = AIConfigTargeting$outboundSchema;
+  })(AIConfigTargeting$ ||= {});
+});
+
+// src/models/components/aiconfigtargetingpatch.ts
+var AIConfigTargetingPatch$inboundSchema, AIConfigTargetingPatch$outboundSchema, AIConfigTargetingPatch$;
+var init_aiconfigtargetingpatch = __esm(() => {
+  init_esm();
+  AIConfigTargetingPatch$inboundSchema = objectType({
+    comment: stringType().optional(),
+    environmentKey: stringType(),
+    instructions: arrayType(recordType(anyType()))
+  });
+  AIConfigTargetingPatch$outboundSchema = objectType({
+    comment: stringType().optional(),
+    environmentKey: stringType(),
+    instructions: arrayType(recordType(anyType()))
+  });
+  ((AIConfigTargetingPatch$) => {
+    AIConfigTargetingPatch$.inboundSchema = AIConfigTargetingPatch$inboundSchema;
+    AIConfigTargetingPatch$.outboundSchema = AIConfigTargetingPatch$outboundSchema;
+  })(AIConfigTargetingPatch$ ||= {});
 });
 
 // src/models/components/aiconfigvariationpatch.ts
@@ -36304,22 +37114,26 @@ var init_aiconfigvariationpatch = __esm(() => {
     AIConfigVariationPatchModel$.outboundSchema = AIConfigVariationPatchModel$outboundSchema;
   })(AIConfigVariationPatchModel$ ||= {});
   AIConfigVariationPatch$inboundSchema = objectType({
+    comment: stringType().optional(),
+    description: stringType().optional(),
+    instructions: stringType().optional(),
     messages: arrayType(Message$inboundSchema).optional(),
     model: lazyType(() => AIConfigVariationPatchModel$inboundSchema).optional(),
     modelConfigKey: stringType().optional(),
     name: stringType().optional(),
     published: booleanType().optional(),
-    state: stringType().optional(),
-    comment: stringType().optional()
+    state: stringType().optional()
   });
   AIConfigVariationPatch$outboundSchema = objectType({
+    comment: stringType().optional(),
+    description: stringType().optional(),
+    instructions: stringType().optional(),
     messages: arrayType(Message$outboundSchema).optional(),
     model: lazyType(() => AIConfigVariationPatchModel$outboundSchema).optional(),
     modelConfigKey: stringType().optional(),
     name: stringType().optional(),
     published: booleanType().optional(),
-    state: stringType().optional(),
-    comment: stringType().optional()
+    state: stringType().optional()
   });
   ((AIConfigVariationPatch$) => {
     AIConfigVariationPatch$.inboundSchema = AIConfigVariationPatch$inboundSchema;
@@ -36339,20 +37153,24 @@ var init_aiconfigvariationpost = __esm(() => {
     AIConfigVariationPostModel$.outboundSchema = AIConfigVariationPostModel$outboundSchema;
   })(AIConfigVariationPostModel$ ||= {});
   AIConfigVariationPost$inboundSchema = objectType({
+    comment: stringType().optional(),
+    description: stringType().optional(),
+    instructions: stringType().optional(),
     key: stringType(),
     messages: arrayType(Message$inboundSchema),
-    model: lazyType(() => AIConfigVariationPostModel$inboundSchema),
+    model: lazyType(() => AIConfigVariationPostModel$inboundSchema).optional(),
     name: stringType(),
-    modelConfigKey: stringType().optional(),
-    comment: stringType().optional()
+    modelConfigKey: stringType().optional()
   });
   AIConfigVariationPost$outboundSchema = objectType({
+    comment: stringType().optional(),
+    description: stringType().optional(),
+    instructions: stringType().optional(),
     key: stringType(),
     messages: arrayType(Message$outboundSchema),
-    model: lazyType(() => AIConfigVariationPostModel$outboundSchema),
+    model: lazyType(() => AIConfigVariationPostModel$outboundSchema).optional(),
     name: stringType(),
-    modelConfigKey: stringType().optional(),
-    comment: stringType().optional()
+    modelConfigKey: stringType().optional()
   });
   ((AIConfigVariationPost$) => {
     AIConfigVariationPost$.inboundSchema = AIConfigVariationPost$inboundSchema;
@@ -36544,22 +37362,22 @@ var init_experimentenvironmentsettingrep = __esm(() => {
 });
 
 // src/models/components/filter.ts
-var Type, Type$inboundSchema, Type$outboundSchema, Type$, Filter$inboundSchema, Filter$outboundSchema, Filter$;
+var FilterType, FilterType$inboundSchema, FilterType$outboundSchema, FilterType$, Filter$inboundSchema, Filter$outboundSchema, Filter$;
 var init_filter = __esm(() => {
   init_esm();
-  Type = {
+  FilterType = {
     Group: "group",
     ContextAttribute: "contextAttribute",
     EventProperty: "eventProperty"
   };
-  Type$inboundSchema = nativeEnumType(Type);
-  Type$outboundSchema = Type$inboundSchema;
-  ((Type$) => {
-    Type$.inboundSchema = Type$inboundSchema;
-    Type$.outboundSchema = Type$outboundSchema;
-  })(Type$ ||= {});
+  FilterType$inboundSchema = nativeEnumType(FilterType);
+  FilterType$outboundSchema = FilterType$inboundSchema;
+  ((FilterType$) => {
+    FilterType$.inboundSchema = FilterType$inboundSchema;
+    FilterType$.outboundSchema = FilterType$outboundSchema;
+  })(FilterType$ ||= {});
   Filter$inboundSchema = objectType({
-    type: Type$inboundSchema,
+    type: FilterType$inboundSchema,
     attribute: stringType().optional(),
     op: stringType(),
     values: arrayType(anyType()),
@@ -36567,7 +37385,7 @@ var init_filter = __esm(() => {
     negate: booleanType()
   });
   Filter$outboundSchema = objectType({
-    type: Type$outboundSchema,
+    type: FilterType$outboundSchema,
     attribute: stringType().optional(),
     op: stringType(),
     values: arrayType(anyType()),
@@ -36671,7 +37489,7 @@ var init_modification = __esm(() => {
 });
 
 // src/models/components/metriclistingrep.ts
-var MetricListingRepKind, SuccessCriteria, UnitAggregationType, AnalysisType, MetricListingRepKind$inboundSchema, MetricListingRepKind$outboundSchema, MetricListingRepKind$, SuccessCriteria$inboundSchema, SuccessCriteria$outboundSchema, SuccessCriteria$, UnitAggregationType$inboundSchema, UnitAggregationType$outboundSchema, UnitAggregationType$, AnalysisType$inboundSchema, AnalysisType$outboundSchema, AnalysisType$, MetricListingRep$inboundSchema, MetricListingRep$outboundSchema, MetricListingRep$;
+var MetricListingRepKind, MetricListingRepSuccessCriteria, MetricListingRepUnitAggregationType, MetricListingRepAnalysisType, MetricListingRepKind$inboundSchema, MetricListingRepKind$outboundSchema, MetricListingRepKind$, MetricListingRepSuccessCriteria$inboundSchema, MetricListingRepSuccessCriteria$outboundSchema, MetricListingRepSuccessCriteria$, MetricListingRepUnitAggregationType$inboundSchema, MetricListingRepUnitAggregationType$outboundSchema, MetricListingRepUnitAggregationType$, MetricListingRepAnalysisType$inboundSchema, MetricListingRepAnalysisType$outboundSchema, MetricListingRepAnalysisType$, MetricListingRep$inboundSchema, MetricListingRep$outboundSchema, MetricListingRep$;
 var init_metriclistingrep = __esm(() => {
   init_esm();
   init_primitives();
@@ -36686,15 +37504,15 @@ var init_metriclistingrep = __esm(() => {
     Click: "click",
     Custom: "custom"
   };
-  SuccessCriteria = {
+  MetricListingRepSuccessCriteria = {
     HigherThanBaseline: "HigherThanBaseline",
     LowerThanBaseline: "LowerThanBaseline"
   };
-  UnitAggregationType = {
+  MetricListingRepUnitAggregationType = {
     Average: "average",
     Sum: "sum"
   };
-  AnalysisType = {
+  MetricListingRepAnalysisType = {
     Mean: "mean",
     Percentile: "percentile"
   };
@@ -36704,24 +37522,24 @@ var init_metriclistingrep = __esm(() => {
     MetricListingRepKind$.inboundSchema = MetricListingRepKind$inboundSchema;
     MetricListingRepKind$.outboundSchema = MetricListingRepKind$outboundSchema;
   })(MetricListingRepKind$ ||= {});
-  SuccessCriteria$inboundSchema = nativeEnumType(SuccessCriteria);
-  SuccessCriteria$outboundSchema = SuccessCriteria$inboundSchema;
-  ((SuccessCriteria$) => {
-    SuccessCriteria$.inboundSchema = SuccessCriteria$inboundSchema;
-    SuccessCriteria$.outboundSchema = SuccessCriteria$outboundSchema;
-  })(SuccessCriteria$ ||= {});
-  UnitAggregationType$inboundSchema = nativeEnumType(UnitAggregationType);
-  UnitAggregationType$outboundSchema = UnitAggregationType$inboundSchema;
-  ((UnitAggregationType$) => {
-    UnitAggregationType$.inboundSchema = UnitAggregationType$inboundSchema;
-    UnitAggregationType$.outboundSchema = UnitAggregationType$outboundSchema;
-  })(UnitAggregationType$ ||= {});
-  AnalysisType$inboundSchema = nativeEnumType(AnalysisType);
-  AnalysisType$outboundSchema = AnalysisType$inboundSchema;
-  ((AnalysisType$) => {
-    AnalysisType$.inboundSchema = AnalysisType$inboundSchema;
-    AnalysisType$.outboundSchema = AnalysisType$outboundSchema;
-  })(AnalysisType$ ||= {});
+  MetricListingRepSuccessCriteria$inboundSchema = nativeEnumType(MetricListingRepSuccessCriteria);
+  MetricListingRepSuccessCriteria$outboundSchema = MetricListingRepSuccessCriteria$inboundSchema;
+  ((MetricListingRepSuccessCriteria$) => {
+    MetricListingRepSuccessCriteria$.inboundSchema = MetricListingRepSuccessCriteria$inboundSchema;
+    MetricListingRepSuccessCriteria$.outboundSchema = MetricListingRepSuccessCriteria$outboundSchema;
+  })(MetricListingRepSuccessCriteria$ ||= {});
+  MetricListingRepUnitAggregationType$inboundSchema = nativeEnumType(MetricListingRepUnitAggregationType);
+  MetricListingRepUnitAggregationType$outboundSchema = MetricListingRepUnitAggregationType$inboundSchema;
+  ((MetricListingRepUnitAggregationType$) => {
+    MetricListingRepUnitAggregationType$.inboundSchema = MetricListingRepUnitAggregationType$inboundSchema;
+    MetricListingRepUnitAggregationType$.outboundSchema = MetricListingRepUnitAggregationType$outboundSchema;
+  })(MetricListingRepUnitAggregationType$ ||= {});
+  MetricListingRepAnalysisType$inboundSchema = nativeEnumType(MetricListingRepAnalysisType);
+  MetricListingRepAnalysisType$outboundSchema = MetricListingRepAnalysisType$inboundSchema;
+  ((MetricListingRepAnalysisType$) => {
+    MetricListingRepAnalysisType$.inboundSchema = MetricListingRepAnalysisType$inboundSchema;
+    MetricListingRepAnalysisType$.outboundSchema = MetricListingRepAnalysisType$outboundSchema;
+  })(MetricListingRepAnalysisType$ ||= {});
   MetricListingRep$inboundSchema = objectType({
     experimentCount: numberType().int().optional(),
     metricGroupCount: numberType().int().optional(),
@@ -36742,13 +37560,13 @@ var init_metriclistingrep = __esm(() => {
     description: stringType().optional(),
     category: stringType().optional(),
     isNumeric: booleanType().optional(),
-    successCriteria: SuccessCriteria$inboundSchema.optional(),
+    successCriteria: MetricListingRepSuccessCriteria$inboundSchema.optional(),
     unit: stringType().optional(),
     eventKey: stringType().optional(),
     randomizationUnits: arrayType(stringType()).optional(),
     filters: Filter$inboundSchema.optional(),
-    unitAggregationType: UnitAggregationType$inboundSchema.optional(),
-    analysisType: AnalysisType$inboundSchema.optional(),
+    unitAggregationType: MetricListingRepUnitAggregationType$inboundSchema.optional(),
+    analysisType: MetricListingRepAnalysisType$inboundSchema.optional(),
     percentileValue: numberType().int().optional(),
     eventDefault: MetricEventDefaultRep$inboundSchema.optional()
   }).transform((v2) => {
@@ -36783,13 +37601,13 @@ var init_metriclistingrep = __esm(() => {
     description: stringType().optional(),
     category: stringType().optional(),
     isNumeric: booleanType().optional(),
-    successCriteria: SuccessCriteria$outboundSchema.optional(),
+    successCriteria: MetricListingRepSuccessCriteria$outboundSchema.optional(),
     unit: stringType().optional(),
     eventKey: stringType().optional(),
     randomizationUnits: arrayType(stringType()).optional(),
     filters: Filter$outboundSchema.optional(),
-    unitAggregationType: UnitAggregationType$outboundSchema.optional(),
-    analysisType: AnalysisType$outboundSchema.optional(),
+    unitAggregationType: MetricListingRepUnitAggregationType$outboundSchema.optional(),
+    analysisType: MetricListingRepAnalysisType$outboundSchema.optional(),
     percentileValue: numberType().int().optional(),
     eventDefault: MetricEventDefaultRep$outboundSchema.optional()
   }).transform((v2) => {
@@ -37574,7 +38392,30 @@ var init_components = __esm(() => {
   init_aiconfigsaccessallowedrep();
   init_aiconfigsaccessdenied();
   init_aiconfigsaccessdeniedreason();
+  init_aiconfigsexperimentenabledperiodrep();
+  init_aiconfigsexperimentenvironmentsettingrep();
+  init_aiconfigsexperimentinforep();
+  init_aiconfigsfilter();
+  init_aiconfigslegacyexperimentrep();
   init_aiconfigslink();
+  init_aiconfigsmembersummary();
+  init_aiconfigsmetriceventdefaultrep();
+  init_aiconfigsmetriclistingrep();
+  init_aiconfigsmodification();
+  init_aiconfigtargeting();
+  init_aiconfigtargetingdefaults();
+  init_aiconfigtargetingenvironment();
+  init_aiconfigtargetingenvironmentfallthrough();
+  init_aiconfigtargetingenvironmentfallthroughrollout();
+  init_aiconfigtargetingenvironmentfallthroughrolloutexperimentationallocation();
+  init_aiconfigtargetingenvironmentfallthroughrolloutvariation();
+  init_aiconfigtargetingenvironmentrule();
+  init_aiconfigtargetingenvironmentruleclause();
+  init_aiconfigtargetingenvironmenttarget();
+  init_aiconfigtargetingpatch();
+  init_aiconfigtargetingvariation();
+  init_aiconfigtargetingvariationjson();
+  init_aiconfigtargetingvariationvalue();
   init_aiconfigvariation();
   init_aiconfigvariationpatch();
   init_aiconfigvariationpost();
@@ -37628,12 +38469,13 @@ var init_components = __esm(() => {
 var ErrorT, ErrorT$inboundSchema, ErrorT$outboundSchema, ErrorT$;
 var init_error = __esm(() => {
   init_esm();
-  ErrorT = class ErrorT extends Error {
+  init_launchdarklyerror();
+  ErrorT = class ErrorT extends LaunchDarklyError {
     code;
     data$;
-    constructor(err) {
-      const message2 = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
-      super(message2);
+    constructor(err, httpMeta) {
+      const message2 = err.message || `API error occurred: ${JSON.stringify(err)}`;
+      super(message2, httpMeta);
       this.data$ = err;
       this.code = err.code;
       this.name = "ErrorT";
@@ -37641,9 +38483,16 @@ var init_error = __esm(() => {
   };
   ErrorT$inboundSchema = objectType({
     message: stringType(),
-    code: stringType()
+    code: stringType(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
   }).transform((v2) => {
-    return new ErrorT(v2);
+    return new ErrorT(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
   });
   ErrorT$outboundSchema = instanceOfType(ErrorT).transform((v2) => v2.data$).pipe(objectType({
     message: stringType(),
@@ -37659,12 +38508,13 @@ var init_error = __esm(() => {
 var ForbiddenErrorRep, ForbiddenErrorRep$inboundSchema, ForbiddenErrorRep$outboundSchema, ForbiddenErrorRep$;
 var init_forbiddenerrorrep = __esm(() => {
   init_esm();
-  ForbiddenErrorRep = class ForbiddenErrorRep extends Error {
+  init_launchdarklyerror();
+  ForbiddenErrorRep = class ForbiddenErrorRep extends LaunchDarklyError {
     code;
     data$;
-    constructor(err) {
-      const message2 = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
-      super(message2);
+    constructor(err, httpMeta) {
+      const message2 = err.message || `API error occurred: ${JSON.stringify(err)}`;
+      super(message2, httpMeta);
       this.data$ = err;
       this.code = err.code;
       this.name = "ForbiddenErrorRep";
@@ -37672,9 +38522,16 @@ var init_forbiddenerrorrep = __esm(() => {
   };
   ForbiddenErrorRep$inboundSchema = objectType({
     code: stringType(),
-    message: stringType()
+    message: stringType(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
   }).transform((v2) => {
-    return new ForbiddenErrorRep(v2);
+    return new ForbiddenErrorRep(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
   });
   ForbiddenErrorRep$outboundSchema = instanceOfType(ForbiddenErrorRep).transform((v2) => v2.data$).pipe(objectType({
     code: stringType(),
@@ -37690,12 +38547,13 @@ var init_forbiddenerrorrep = __esm(() => {
 var InvalidRequestErrorRep, InvalidRequestErrorRep$inboundSchema, InvalidRequestErrorRep$outboundSchema, InvalidRequestErrorRep$;
 var init_invalidrequesterrorrep = __esm(() => {
   init_esm();
-  InvalidRequestErrorRep = class InvalidRequestErrorRep extends Error {
+  init_launchdarklyerror();
+  InvalidRequestErrorRep = class InvalidRequestErrorRep extends LaunchDarklyError {
     code;
     data$;
-    constructor(err) {
-      const message2 = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
-      super(message2);
+    constructor(err, httpMeta) {
+      const message2 = err.message || `API error occurred: ${JSON.stringify(err)}`;
+      super(message2, httpMeta);
       this.data$ = err;
       this.code = err.code;
       this.name = "InvalidRequestErrorRep";
@@ -37703,9 +38561,16 @@ var init_invalidrequesterrorrep = __esm(() => {
   };
   InvalidRequestErrorRep$inboundSchema = objectType({
     code: stringType(),
-    message: stringType()
+    message: stringType(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
   }).transform((v2) => {
-    return new InvalidRequestErrorRep(v2);
+    return new InvalidRequestErrorRep(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
   });
   InvalidRequestErrorRep$outboundSchema = instanceOfType(InvalidRequestErrorRep).transform((v2) => v2.data$).pipe(objectType({
     code: stringType(),
@@ -37721,12 +38586,13 @@ var init_invalidrequesterrorrep = __esm(() => {
 var MethodNotAllowedErrorRep, MethodNotAllowedErrorRep$inboundSchema, MethodNotAllowedErrorRep$outboundSchema, MethodNotAllowedErrorRep$;
 var init_methodnotallowederrorrep = __esm(() => {
   init_esm();
-  MethodNotAllowedErrorRep = class MethodNotAllowedErrorRep extends Error {
+  init_launchdarklyerror();
+  MethodNotAllowedErrorRep = class MethodNotAllowedErrorRep extends LaunchDarklyError {
     code;
     data$;
-    constructor(err) {
-      const message2 = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
-      super(message2);
+    constructor(err, httpMeta) {
+      const message2 = err.message || `API error occurred: ${JSON.stringify(err)}`;
+      super(message2, httpMeta);
       this.data$ = err;
       this.code = err.code;
       this.name = "MethodNotAllowedErrorRep";
@@ -37734,9 +38600,16 @@ var init_methodnotallowederrorrep = __esm(() => {
   };
   MethodNotAllowedErrorRep$inboundSchema = objectType({
     code: stringType(),
-    message: stringType()
+    message: stringType(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
   }).transform((v2) => {
-    return new MethodNotAllowedErrorRep(v2);
+    return new MethodNotAllowedErrorRep(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
   });
   MethodNotAllowedErrorRep$outboundSchema = instanceOfType(MethodNotAllowedErrorRep).transform((v2) => v2.data$).pipe(objectType({
     code: stringType(),
@@ -37752,12 +38625,13 @@ var init_methodnotallowederrorrep = __esm(() => {
 var NotFoundErrorRep, NotFoundErrorRep$inboundSchema, NotFoundErrorRep$outboundSchema, NotFoundErrorRep$;
 var init_notfounderrorrep = __esm(() => {
   init_esm();
-  NotFoundErrorRep = class NotFoundErrorRep extends Error {
+  init_launchdarklyerror();
+  NotFoundErrorRep = class NotFoundErrorRep extends LaunchDarklyError {
     code;
     data$;
-    constructor(err) {
-      const message2 = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
-      super(message2);
+    constructor(err, httpMeta) {
+      const message2 = err.message || `API error occurred: ${JSON.stringify(err)}`;
+      super(message2, httpMeta);
       this.data$ = err;
       this.code = err.code;
       this.name = "NotFoundErrorRep";
@@ -37765,9 +38639,16 @@ var init_notfounderrorrep = __esm(() => {
   };
   NotFoundErrorRep$inboundSchema = objectType({
     code: stringType(),
-    message: stringType()
+    message: stringType(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
   }).transform((v2) => {
-    return new NotFoundErrorRep(v2);
+    return new NotFoundErrorRep(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
   });
   NotFoundErrorRep$outboundSchema = instanceOfType(NotFoundErrorRep).transform((v2) => v2.data$).pipe(objectType({
     code: stringType(),
@@ -37783,12 +38664,13 @@ var init_notfounderrorrep = __esm(() => {
 var RateLimitedErrorRep, RateLimitedErrorRep$inboundSchema, RateLimitedErrorRep$outboundSchema, RateLimitedErrorRep$;
 var init_ratelimitederrorrep = __esm(() => {
   init_esm();
-  RateLimitedErrorRep = class RateLimitedErrorRep extends Error {
+  init_launchdarklyerror();
+  RateLimitedErrorRep = class RateLimitedErrorRep extends LaunchDarklyError {
     code;
     data$;
-    constructor(err) {
-      const message2 = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
-      super(message2);
+    constructor(err, httpMeta) {
+      const message2 = err.message || `API error occurred: ${JSON.stringify(err)}`;
+      super(message2, httpMeta);
       this.data$ = err;
       this.code = err.code;
       this.name = "RateLimitedErrorRep";
@@ -37796,9 +38678,16 @@ var init_ratelimitederrorrep = __esm(() => {
   };
   RateLimitedErrorRep$inboundSchema = objectType({
     code: stringType(),
-    message: stringType()
+    message: stringType(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
   }).transform((v2) => {
-    return new RateLimitedErrorRep(v2);
+    return new RateLimitedErrorRep(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
   });
   RateLimitedErrorRep$outboundSchema = instanceOfType(RateLimitedErrorRep).transform((v2) => v2.data$).pipe(objectType({
     code: stringType(),
@@ -37814,12 +38703,13 @@ var init_ratelimitederrorrep = __esm(() => {
 var StatusConflictErrorRep, StatusConflictErrorRep$inboundSchema, StatusConflictErrorRep$outboundSchema, StatusConflictErrorRep$;
 var init_statusconflicterrorrep = __esm(() => {
   init_esm();
-  StatusConflictErrorRep = class StatusConflictErrorRep extends Error {
+  init_launchdarklyerror();
+  StatusConflictErrorRep = class StatusConflictErrorRep extends LaunchDarklyError {
     code;
     data$;
-    constructor(err) {
-      const message2 = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
-      super(message2);
+    constructor(err, httpMeta) {
+      const message2 = err.message || `API error occurred: ${JSON.stringify(err)}`;
+      super(message2, httpMeta);
       this.data$ = err;
       this.code = err.code;
       this.name = "StatusConflictErrorRep";
@@ -37827,9 +38717,16 @@ var init_statusconflicterrorrep = __esm(() => {
   };
   StatusConflictErrorRep$inboundSchema = objectType({
     code: stringType(),
-    message: stringType()
+    message: stringType(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
   }).transform((v2) => {
-    return new StatusConflictErrorRep(v2);
+    return new StatusConflictErrorRep(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
   });
   StatusConflictErrorRep$outboundSchema = instanceOfType(StatusConflictErrorRep).transform((v2) => v2.data$).pipe(objectType({
     code: stringType(),
@@ -37845,12 +38742,13 @@ var init_statusconflicterrorrep = __esm(() => {
 var UnauthorizedErrorRep, UnauthorizedErrorRep$inboundSchema, UnauthorizedErrorRep$outboundSchema, UnauthorizedErrorRep$;
 var init_unauthorizederrorrep = __esm(() => {
   init_esm();
-  UnauthorizedErrorRep = class UnauthorizedErrorRep extends Error {
+  init_launchdarklyerror();
+  UnauthorizedErrorRep = class UnauthorizedErrorRep extends LaunchDarklyError {
     code;
     data$;
-    constructor(err) {
-      const message2 = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
-      super(message2);
+    constructor(err, httpMeta) {
+      const message2 = err.message || `API error occurred: ${JSON.stringify(err)}`;
+      super(message2, httpMeta);
       this.data$ = err;
       this.code = err.code;
       this.name = "UnauthorizedErrorRep";
@@ -37858,9 +38756,16 @@ var init_unauthorizederrorrep = __esm(() => {
   };
   UnauthorizedErrorRep$inboundSchema = objectType({
     code: stringType(),
-    message: stringType()
+    message: stringType(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
   }).transform((v2) => {
-    return new UnauthorizedErrorRep(v2);
+    return new UnauthorizedErrorRep(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
   });
   UnauthorizedErrorRep$outboundSchema = instanceOfType(UnauthorizedErrorRep).transform((v2) => v2.data$).pipe(objectType({
     code: stringType(),
@@ -37882,6 +38787,7 @@ var init_errors2 = __esm(() => {
   init_methodnotallowederrorrep();
   init_notfounderrorrep();
   init_ratelimitederrorrep();
+  init_responsevalidationerror();
   init_sdkvalidationerror();
   init_statusconflicterrorrep();
   init_unauthorizederrorrep();
@@ -38065,6 +38971,44 @@ var init_getaiconfigs = __esm(() => {
   })(GetAIConfigsRequest$ ||= {});
 });
 
+// src/models/operations/getaiconfigtargeting.ts
+var GetAIConfigTargetingLDAPIVersion, GetAIConfigTargetingLDAPIVersion$inboundSchema, GetAIConfigTargetingLDAPIVersion$outboundSchema, GetAIConfigTargetingLDAPIVersion$, GetAIConfigTargetingRequest$inboundSchema, GetAIConfigTargetingRequest$outboundSchema, GetAIConfigTargetingRequest$;
+var init_getaiconfigtargeting = __esm(() => {
+  init_esm();
+  init_primitives();
+  GetAIConfigTargetingLDAPIVersion = {
+    Beta: "beta"
+  };
+  GetAIConfigTargetingLDAPIVersion$inboundSchema = nativeEnumType(GetAIConfigTargetingLDAPIVersion);
+  GetAIConfigTargetingLDAPIVersion$outboundSchema = GetAIConfigTargetingLDAPIVersion$inboundSchema;
+  ((GetAIConfigTargetingLDAPIVersion$) => {
+    GetAIConfigTargetingLDAPIVersion$.inboundSchema = GetAIConfigTargetingLDAPIVersion$inboundSchema;
+    GetAIConfigTargetingLDAPIVersion$.outboundSchema = GetAIConfigTargetingLDAPIVersion$outboundSchema;
+  })(GetAIConfigTargetingLDAPIVersion$ ||= {});
+  GetAIConfigTargetingRequest$inboundSchema = objectType({
+    "LD-API-Version": GetAIConfigTargetingLDAPIVersion$inboundSchema,
+    projectKey: stringType(),
+    configKey: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      "LD-API-Version": "ldAPIVersion"
+    });
+  });
+  GetAIConfigTargetingRequest$outboundSchema = objectType({
+    ldAPIVersion: GetAIConfigTargetingLDAPIVersion$outboundSchema,
+    projectKey: stringType(),
+    configKey: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      ldAPIVersion: "LD-API-Version"
+    });
+  });
+  ((GetAIConfigTargetingRequest$) => {
+    GetAIConfigTargetingRequest$.inboundSchema = GetAIConfigTargetingRequest$inboundSchema;
+    GetAIConfigTargetingRequest$.outboundSchema = GetAIConfigTargetingRequest$outboundSchema;
+  })(GetAIConfigTargetingRequest$ ||= {});
+});
+
 // src/models/operations/getaiconfigvariation.ts
 var GetAIConfigVariationLDAPIVersion, GetAIConfigVariationLDAPIVersion$inboundSchema, GetAIConfigVariationLDAPIVersion$outboundSchema, GetAIConfigVariationLDAPIVersion$, GetAIConfigVariationRequest$inboundSchema, GetAIConfigVariationRequest$outboundSchema, GetAIConfigVariationRequest$;
 var init_getaiconfigvariation = __esm(() => {
@@ -38206,6 +39150,49 @@ var init_patchaiconfig = __esm(() => {
   })(PatchAIConfigRequest$ ||= {});
 });
 
+// src/models/operations/patchaiconfigtargeting.ts
+var PatchAIConfigTargetingLDAPIVersion, PatchAIConfigTargetingLDAPIVersion$inboundSchema, PatchAIConfigTargetingLDAPIVersion$outboundSchema, PatchAIConfigTargetingLDAPIVersion$, PatchAIConfigTargetingRequest$inboundSchema, PatchAIConfigTargetingRequest$outboundSchema, PatchAIConfigTargetingRequest$;
+var init_patchaiconfigtargeting = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  PatchAIConfigTargetingLDAPIVersion = {
+    Beta: "beta"
+  };
+  PatchAIConfigTargetingLDAPIVersion$inboundSchema = nativeEnumType(PatchAIConfigTargetingLDAPIVersion);
+  PatchAIConfigTargetingLDAPIVersion$outboundSchema = PatchAIConfigTargetingLDAPIVersion$inboundSchema;
+  ((PatchAIConfigTargetingLDAPIVersion$) => {
+    PatchAIConfigTargetingLDAPIVersion$.inboundSchema = PatchAIConfigTargetingLDAPIVersion$inboundSchema;
+    PatchAIConfigTargetingLDAPIVersion$.outboundSchema = PatchAIConfigTargetingLDAPIVersion$outboundSchema;
+  })(PatchAIConfigTargetingLDAPIVersion$ ||= {});
+  PatchAIConfigTargetingRequest$inboundSchema = objectType({
+    "LD-API-Version": PatchAIConfigTargetingLDAPIVersion$inboundSchema,
+    projectKey: stringType(),
+    configKey: stringType(),
+    AIConfigTargetingPatch: AIConfigTargetingPatch$inboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "LD-API-Version": "ldAPIVersion",
+      AIConfigTargetingPatch: "aiConfigTargetingPatch"
+    });
+  });
+  PatchAIConfigTargetingRequest$outboundSchema = objectType({
+    ldAPIVersion: PatchAIConfigTargetingLDAPIVersion$outboundSchema,
+    projectKey: stringType(),
+    configKey: stringType(),
+    aiConfigTargetingPatch: AIConfigTargetingPatch$outboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      ldAPIVersion: "LD-API-Version",
+      aiConfigTargetingPatch: "AIConfigTargetingPatch"
+    });
+  });
+  ((PatchAIConfigTargetingRequest$) => {
+    PatchAIConfigTargetingRequest$.inboundSchema = PatchAIConfigTargetingRequest$inboundSchema;
+    PatchAIConfigTargetingRequest$.outboundSchema = PatchAIConfigTargetingRequest$outboundSchema;
+  })(PatchAIConfigTargetingRequest$ ||= {});
+});
+
 // src/models/operations/patchaiconfigvariation.ts
 var PatchAIConfigVariationLDAPIVersion, PatchAIConfigVariationLDAPIVersion$inboundSchema, PatchAIConfigVariationLDAPIVersion$outboundSchema, PatchAIConfigVariationLDAPIVersion$, PatchAIConfigVariationRequest$inboundSchema, PatchAIConfigVariationRequest$outboundSchema, PatchAIConfigVariationRequest$;
 var init_patchaiconfigvariation = __esm(() => {
@@ -38404,10 +39391,12 @@ var init_operations = __esm(() => {
   init_deletefeatureflag();
   init_getaiconfig();
   init_getaiconfigs();
+  init_getaiconfigtargeting();
   init_getaiconfigvariation();
   init_getfeatureflag();
   init_getfeatureflags();
   init_patchaiconfig();
+  init_patchaiconfigtargeting();
   init_patchaiconfigvariation();
   init_patchfeatureflag();
   init_postaiconfig();
@@ -38504,7 +39493,7 @@ async function $do(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, AIConfig$inboundSchema), jsonErr([400, 403], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, AIConfig$inboundSchema), jsonErr([400, 403], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -38621,7 +39610,7 @@ async function $do2(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, AIConfigVariation$inboundSchema), jsonErr([400, 403], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, AIConfigVariation$inboundSchema), jsonErr([400, 403], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -38735,7 +39724,7 @@ async function $do3(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(204, voidType()), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(nil(204, voidType()), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -38786,8 +39775,124 @@ var init_aiConfigsDelete2 = __esm(() => {
 function aiConfigsDeleteVariation(client, request, options) {
   return new APIPromise($do4(client, request, options));
 }
-async function $do4(client, request, options) {
-  const parsed = safeParse(request, (value) => DeleteAIConfigVariationRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do4(client, request, options) {
+  const parsed = safeParse(request, (value) => DeleteAIConfigVariationRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    configKey: encodeSimple("configKey", payload.configKey, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    projectKey: encodeSimple("projectKey", payload.projectKey, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    variationKey: encodeSimple("variationKey", payload.variationKey, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v2/projects/{projectKey}/ai-configs/{configKey}/variations/{variationKey}")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "LD-API-Version": encodeSimple("LD-API-Version", payload["LD-API-Version"], { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.apiKey);
+  const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "deleteAIConfigVariation",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKey,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "DELETE",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["400", "403", "404", "4XX", "500", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(nil(204, voidType()), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_aiConfigsDeleteVariation = __esm(() => {
+  init_esm();
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/aiConfigsDeleteVariation.ts
+var args4, tool$aiConfigsDeleteVariation;
+var init_aiConfigsDeleteVariation2 = __esm(() => {
+  init_aiConfigsDeleteVariation();
+  init_operations();
+  init_tools();
+  args4 = {
+    request: DeleteAIConfigVariationRequest$inboundSchema
+  };
+  tool$aiConfigsDeleteVariation = {
+    name: "delete-ai-config-variation",
+    description: `Deletes an AI Config variation.`,
+    scopes: ["write"],
+    args: args4,
+    tool: async (client, args5, ctx) => {
+      const [result, apiCall] = await aiConfigsDeleteVariation(client, args5.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(undefined, apiCall);
+    }
+  };
+});
+
+// src/funcs/aiConfigsGet.ts
+function aiConfigsGet(client, request, options) {
+  return new APIPromise($do5(client, request, options));
+}
+async function $do5(client, request, options) {
+  const parsed = safeParse(request, (value) => GetAIConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -38801,13 +39906,9 @@ async function $do4(client, request, options) {
     projectKey: encodeSimple("projectKey", payload.projectKey, {
       explode: false,
       charEncoding: "percent"
-    }),
-    variationKey: encodeSimple("variationKey", payload.variationKey, {
-      explode: false,
-      charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/api/v2/projects/{projectKey}/ai-configs/{configKey}/variations/{variationKey}")(pathParams);
+  const path = pathToFunc("/api/v2/projects/{projectKey}/ai-configs/{configKey}")(pathParams);
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "LD-API-Version": encodeSimple("LD-API-Version", payload["LD-API-Version"], { explode: false, charEncoding: "none" })
@@ -38818,7 +39919,7 @@ async function $do4(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "deleteAIConfigVariation",
+    operationID: "getAIConfig",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.apiKey,
@@ -38827,7 +39928,7 @@ async function $do4(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "DELETE",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -38852,58 +39953,59 @@ async function $do4(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(204, voidType()), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, AIConfig$inboundSchema), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_aiConfigsDeleteVariation = __esm(() => {
-  init_esm();
+var init_aiConfigsGet = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
+  init_components();
   init_errors2();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/aiConfigsDeleteVariation.ts
-var args4, tool$aiConfigsDeleteVariation;
-var init_aiConfigsDeleteVariation2 = __esm(() => {
-  init_aiConfigsDeleteVariation();
+// src/mcp-server/tools/aiConfigsGet.ts
+var args5, tool$aiConfigsGet;
+var init_aiConfigsGet2 = __esm(() => {
+  init_aiConfigsGet();
   init_operations();
   init_tools();
-  args4 = {
-    request: DeleteAIConfigVariationRequest$inboundSchema
+  args5 = {
+    request: GetAIConfigRequest$inboundSchema
   };
-  tool$aiConfigsDeleteVariation = {
-    name: "delete-ai-config-variation",
-    description: `Deletes an AI Config variation.`,
-    scopes: ["write"],
-    args: args4,
-    tool: async (client, args5, ctx) => {
-      const [result, apiCall] = await aiConfigsDeleteVariation(client, args5.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  tool$aiConfigsGet = {
+    name: "get-ai-config",
+    description: `Retrieves details of a specific AI Config, including variations and model settings.`,
+    scopes: ["read"],
+    args: args5,
+    tool: async (client, args6, ctx) => {
+      const [result, apiCall] = await aiConfigsGet(client, args6.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
           isError: true
         };
       }
-      return formatResult(undefined, apiCall);
+      const value = result.value;
+      return formatResult(value, apiCall);
     }
   };
 });
 
-// src/funcs/aiConfigsGet.ts
-function aiConfigsGet(client, request, options) {
-  return new APIPromise($do5(client, request, options));
+// src/funcs/aiConfigsGetTargeting.ts
+function aiConfigsGetTargeting(client, request, options) {
+  return new APIPromise($do6(client, request, options));
 }
-async function $do5(client, request, options) {
-  const parsed = safeParse(request, (value) => GetAIConfigRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do6(client, request, options) {
+  const parsed = safeParse(request, (value) => GetAIConfigTargetingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -38919,7 +40021,7 @@ async function $do5(client, request, options) {
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/api/v2/projects/{projectKey}/ai-configs/{configKey}")(pathParams);
+  const path = pathToFunc("/api/v2/projects/{projectKey}/ai-configs/{configKey}/targeting")(pathParams);
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "LD-API-Version": encodeSimple("LD-API-Version", payload["LD-API-Version"], { explode: false, charEncoding: "none" })
@@ -38930,7 +40032,7 @@ async function $do5(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getAIConfig",
+    operationID: "getAIConfigTargeting",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.apiKey,
@@ -38953,7 +40055,7 @@ async function $do5(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "403", "404", "4XX", "500", "5XX"],
+    errorCodes: ["403", "404", "4XX", "500", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -38964,13 +40066,13 @@ async function $do5(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, AIConfig$inboundSchema), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, AIConfigTargeting$inboundSchema), jsonErr([403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_aiConfigsGet = __esm(() => {
+var init_aiConfigsGetTargeting = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -38983,22 +40085,22 @@ var init_aiConfigsGet = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/aiConfigsGet.ts
-var args5, tool$aiConfigsGet;
-var init_aiConfigsGet2 = __esm(() => {
-  init_aiConfigsGet();
+// src/mcp-server/tools/aiConfigsGetTargeting.ts
+var args6, tool$aiConfigsGetTargeting;
+var init_aiConfigsGetTargeting2 = __esm(() => {
+  init_aiConfigsGetTargeting();
   init_operations();
   init_tools();
-  args5 = {
-    request: GetAIConfigRequest$inboundSchema
+  args6 = {
+    request: GetAIConfigTargetingRequest$inboundSchema
   };
-  tool$aiConfigsGet = {
-    name: "get-ai-config",
-    description: `Retrieves details of a specific AI Config, including variations and model settings.`,
+  tool$aiConfigsGetTargeting = {
+    name: "get-ai-config-targeting",
+    description: `Retrieves the targeting details of a specific AI Config, including individual targets, rules, and rollouts.`,
     scopes: ["read"],
-    args: args5,
-    tool: async (client, args6, ctx) => {
-      const [result, apiCall] = await aiConfigsGet(client, args6.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args6,
+    tool: async (client, args7, ctx) => {
+      const [result, apiCall] = await aiConfigsGetTargeting(client, args7.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -39013,9 +40115,9 @@ var init_aiConfigsGet2 = __esm(() => {
 
 // src/funcs/aiConfigsGetVariation.ts
 function aiConfigsGetVariation(client, request, options) {
-  return new APIPromise($do6(client, request, options));
+  return new APIPromise($do7(client, request, options));
 }
-async function $do6(client, request, options) {
+async function $do7(client, request, options) {
   const parsed = safeParse(request, (value) => GetAIConfigVariationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -39081,7 +40183,7 @@ async function $do6(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, AIConfigVariationsResponse$inboundSchema), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, AIConfigVariationsResponse$inboundSchema), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -39101,21 +40203,21 @@ var init_aiConfigsGetVariation = __esm(() => {
 });
 
 // src/mcp-server/tools/aiConfigsGetVariation.ts
-var args6, tool$aiConfigsGetVariation;
+var args7, tool$aiConfigsGetVariation;
 var init_aiConfigsGetVariation2 = __esm(() => {
   init_aiConfigsGetVariation();
   init_operations();
   init_tools();
-  args6 = {
+  args7 = {
     request: GetAIConfigVariationRequest$inboundSchema
   };
   tool$aiConfigsGetVariation = {
     name: "get-ai-config-variation",
     description: `Retrieves an AI configuration variation.`,
     scopes: ["read"],
-    args: args6,
-    tool: async (client, args7, ctx) => {
-      const [result, apiCall] = await aiConfigsGetVariation(client, args7.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args7,
+    tool: async (client, args8, ctx) => {
+      const [result, apiCall] = await aiConfigsGetVariation(client, args8.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -39130,9 +40232,9 @@ var init_aiConfigsGetVariation2 = __esm(() => {
 
 // src/funcs/aiConfigsList.ts
 function aiConfigsList(client, request, options) {
-  return new APIPromise($do7(client, request, options));
+  return new APIPromise($do8(client, request, options));
 }
-async function $do7(client, request, options) {
+async function $do8(client, request, options) {
   const parsed = safeParse(request, (value) => GetAIConfigsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -39197,7 +40299,7 @@ async function $do7(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, AIConfigs$inboundSchema), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, AIConfigs$inboundSchema), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -39217,12 +40319,12 @@ var init_aiConfigsList = __esm(() => {
 });
 
 // src/mcp-server/tools/aiConfigsList.ts
-var args7, tool$aiConfigsList;
+var args8, tool$aiConfigsList;
 var init_aiConfigsList2 = __esm(() => {
   init_aiConfigsList();
   init_operations();
   init_tools();
-  args7 = {
+  args8 = {
     request: GetAIConfigsRequest$inboundSchema
   };
   tool$aiConfigsList = {
@@ -39230,9 +40332,9 @@ var init_aiConfigsList2 = __esm(() => {
     description: `Retrieves AI configuration settings for a specific project. This endpoint allows agents to access and modify AI-related configurations, ensuring that the AI's behavior aligns with project requirements and user expectations.
 `,
     scopes: ["read"],
-    args: args7,
-    tool: async (client, args8, ctx) => {
-      const [result, apiCall] = await aiConfigsList(client, args8.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args8,
+    tool: async (client, args9, ctx) => {
+      const [result, apiCall] = await aiConfigsList(client, args9.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -39247,9 +40349,9 @@ var init_aiConfigsList2 = __esm(() => {
 
 // src/funcs/aiConfigsUpdate.ts
 function aiConfigsUpdate(client, request, options) {
-  return new APIPromise($do8(client, request, options));
+  return new APIPromise($do9(client, request, options));
 }
-async function $do8(client, request, options) {
+async function $do9(client, request, options) {
   const parsed = safeParse(request, (value) => PatchAIConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -39312,7 +40414,7 @@ async function $do8(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, AIConfig$inboundSchema), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, AIConfig$inboundSchema), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -39332,21 +40434,137 @@ var init_aiConfigsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/aiConfigsUpdate.ts
-var args8, tool$aiConfigsUpdate;
+var args9, tool$aiConfigsUpdate;
 var init_aiConfigsUpdate2 = __esm(() => {
   init_aiConfigsUpdate();
   init_operations();
   init_tools();
-  args8 = {
+  args9 = {
     request: PatchAIConfigRequest$inboundSchema
   };
   tool$aiConfigsUpdate = {
     name: "update-ai-config",
     description: `Updates metadata or configuration of an existing AI Config.`,
     scopes: ["write"],
-    args: args8,
-    tool: async (client, args9, ctx) => {
-      const [result, apiCall] = await aiConfigsUpdate(client, args9.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args9,
+    tool: async (client, args10, ctx) => {
+      const [result, apiCall] = await aiConfigsUpdate(client, args10.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/aiConfigsUpdateTargeting.ts
+function aiConfigsUpdateTargeting(client, request, options) {
+  return new APIPromise($do10(client, request, options));
+}
+async function $do10(client, request, options) {
+  const parsed = safeParse(request, (value) => PatchAIConfigTargetingRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.AIConfigTargetingPatch, {
+    explode: true
+  });
+  const pathParams = {
+    configKey: encodeSimple("configKey", payload.configKey, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    projectKey: encodeSimple("projectKey", payload.projectKey, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v2/projects/{projectKey}/ai-configs/{configKey}/targeting")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "LD-API-Version": encodeSimple("LD-API-Version", payload["LD-API-Version"], { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.apiKey);
+  const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "patchAIConfigTargeting",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKey,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "PATCH",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["400", "403", "404", "4XX", "500", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, AIConfigTargeting$inboundSchema), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_aiConfigsUpdateTargeting = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/aiConfigsUpdateTargeting.ts
+var args10, tool$aiConfigsUpdateTargeting;
+var init_aiConfigsUpdateTargeting2 = __esm(() => {
+  init_aiConfigsUpdateTargeting();
+  init_operations();
+  init_tools();
+  args10 = {
+    request: PatchAIConfigTargetingRequest$inboundSchema
+  };
+  tool$aiConfigsUpdateTargeting = {
+    name: "update-ai-config-targeting",
+    description: `Updates the targeting of an existing AI Config.`,
+    scopes: ["write"],
+    args: args10,
+    tool: async (client, args11, ctx) => {
+      const [result, apiCall] = await aiConfigsUpdateTargeting(client, args11.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -39361,9 +40579,9 @@ var init_aiConfigsUpdate2 = __esm(() => {
 
 // src/funcs/aiConfigsUpdateVariation.ts
 function aiConfigsUpdateVariation(client, request, options) {
-  return new APIPromise($do9(client, request, options));
+  return new APIPromise($do11(client, request, options));
 }
-async function $do9(client, request, options) {
+async function $do11(client, request, options) {
   const parsed = safeParse(request, (value) => PatchAIConfigVariationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -39432,7 +40650,7 @@ async function $do9(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, AIConfigVariation$inboundSchema), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, AIConfigVariation$inboundSchema), jsonErr([400, 403, 404], ErrorT$inboundSchema), jsonErr(500, ErrorT$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -39452,12 +40670,12 @@ var init_aiConfigsUpdateVariation = __esm(() => {
 });
 
 // src/mcp-server/tools/aiConfigsUpdateVariation.ts
-var args9, tool$aiConfigsUpdateVariation;
+var args11, tool$aiConfigsUpdateVariation;
 var init_aiConfigsUpdateVariation2 = __esm(() => {
   init_aiConfigsUpdateVariation();
   init_operations();
   init_tools();
-  args9 = {
+  args11 = {
     request: PatchAIConfigVariationRequest$inboundSchema
   };
   tool$aiConfigsUpdateVariation = {
@@ -39465,9 +40683,9 @@ var init_aiConfigsUpdateVariation2 = __esm(() => {
     description: `Updates a specific variation within an AI Config. Enables fine-tuned control of model behavior.
 `,
     scopes: ["write"],
-    args: args9,
-    tool: async (client, args10, ctx) => {
-      const [result, apiCall] = await aiConfigsUpdateVariation(client, args10.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args11,
+    tool: async (client, args12, ctx) => {
+      const [result, apiCall] = await aiConfigsUpdateVariation(client, args12.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -39482,9 +40700,9 @@ var init_aiConfigsUpdateVariation2 = __esm(() => {
 
 // src/funcs/featureFlagsCreate.ts
 function featureFlagsCreate(client, request, options) {
-  return new APIPromise($do10(client, request, options));
+  return new APIPromise($do12(client, request, options));
 }
-async function $do10(client, request, options) {
+async function $do12(client, request, options) {
   const parsed = safeParse(request, (value) => PostFeatureFlagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -39546,7 +40764,7 @@ async function $do10(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, FeatureFlag$inboundSchema), jsonErr(400, InvalidRequestErrorRep$inboundSchema), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(409, StatusConflictErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, FeatureFlag$inboundSchema), jsonErr(400, InvalidRequestErrorRep$inboundSchema), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(409, StatusConflictErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -39566,12 +40784,12 @@ var init_featureFlagsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/featureFlagsCreate.ts
-var args10, tool$featureFlagsCreate;
+var args12, tool$featureFlagsCreate;
 var init_featureFlagsCreate2 = __esm(() => {
   init_featureFlagsCreate();
   init_operations();
   init_tools();
-  args10 = {
+  args12 = {
     request: PostFeatureFlagRequest$inboundSchema
   };
   tool$featureFlagsCreate = {
@@ -39579,9 +40797,9 @@ var init_featureFlagsCreate2 = __esm(() => {
     description: `Creates a new feature flag within a project. AI agents can use this operation to define feature toggles for controlled rollouts, experimentation, or gated features, automating the flag setup process.
 `,
     scopes: ["write"],
-    args: args10,
-    tool: async (client, args11, ctx) => {
-      const [result, apiCall] = await featureFlagsCreate(client, args11.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args12,
+    tool: async (client, args13, ctx) => {
+      const [result, apiCall] = await featureFlagsCreate(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -39596,9 +40814,9 @@ var init_featureFlagsCreate2 = __esm(() => {
 
 // src/funcs/featureFlagsDelete.ts
 function featureFlagsDelete(client, request, options) {
-  return new APIPromise($do11(client, request, options));
+  return new APIPromise($do13(client, request, options));
 }
-async function $do11(client, request, options) {
+async function $do13(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteFeatureFlagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -39659,7 +40877,7 @@ async function $do11(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(204, voidType()), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(404, NotFoundErrorRep$inboundSchema), jsonErr(409, StatusConflictErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(nil(204, voidType()), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(404, NotFoundErrorRep$inboundSchema), jsonErr(409, StatusConflictErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -39679,12 +40897,12 @@ var init_featureFlagsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/featureFlagsDelete.ts
-var args11, tool$featureFlagsDelete;
+var args13, tool$featureFlagsDelete;
 var init_featureFlagsDelete2 = __esm(() => {
   init_featureFlagsDelete();
   init_operations();
   init_tools();
-  args11 = {
+  args13 = {
     request: DeleteFeatureFlagRequest$inboundSchema
   };
   tool$featureFlagsDelete = {
@@ -39692,9 +40910,9 @@ var init_featureFlagsDelete2 = __esm(() => {
     description: `Removes a feature flag from the project. Used by AI agents to clean up deprecated toggles that are no longer in use, improving system hygiene and maintainability.
 `,
     scopes: ["write"],
-    args: args11,
-    tool: async (client, args12, ctx) => {
-      const [result, apiCall] = await featureFlagsDelete(client, args12.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args13,
+    tool: async (client, args14, ctx) => {
+      const [result, apiCall] = await featureFlagsDelete(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -39708,9 +40926,9 @@ var init_featureFlagsDelete2 = __esm(() => {
 
 // src/funcs/featureFlagsGet.ts
 function featureFlagsGet(client, request, options) {
-  return new APIPromise($do12(client, request, options));
+  return new APIPromise($do14(client, request, options));
 }
-async function $do12(client, request, options) {
+async function $do14(client, request, options) {
   const parsed = safeParse(request, (value) => GetFeatureFlagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -39776,7 +40994,7 @@ async function $do12(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, FeatureFlag$inboundSchema), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(403, ForbiddenErrorRep$inboundSchema), jsonErr(404, NotFoundErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, FeatureFlag$inboundSchema), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(403, ForbiddenErrorRep$inboundSchema), jsonErr(404, NotFoundErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -39796,12 +41014,12 @@ var init_featureFlagsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/featureFlagsGet.ts
-var args12, tool$featureFlagsGet;
+var args14, tool$featureFlagsGet;
 var init_featureFlagsGet2 = __esm(() => {
   init_featureFlagsGet();
   init_operations();
   init_tools();
-  args12 = {
+  args14 = {
     request: GetFeatureFlagRequest$inboundSchema
   };
   tool$featureFlagsGet = {
@@ -39809,9 +41027,9 @@ var init_featureFlagsGet2 = __esm(() => {
     description: `Fetches the full configuration for a specific feature flag, including environments, variations, and targeting rules. Useful for agents auditing or managing specific feature toggles in a detailed, contextual manner.
 `,
     scopes: ["read"],
-    args: args12,
-    tool: async (client, args13, ctx) => {
-      const [result, apiCall] = await featureFlagsGet(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args14,
+    tool: async (client, args15, ctx) => {
+      const [result, apiCall] = await featureFlagsGet(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -39826,9 +41044,9 @@ var init_featureFlagsGet2 = __esm(() => {
 
 // src/funcs/featureFlagsList.ts
 function featureFlagsList(client, request, options) {
-  return new APIPromise($do13(client, request, options));
+  return new APIPromise($do15(client, request, options));
 }
-async function $do13(client, request, options) {
+async function $do15(client, request, options) {
   const parsed = safeParse(request, (value) => GetFeatureFlagsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -39898,7 +41116,7 @@ async function $do13(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, FeatureFlags$inboundSchema), jsonErr(400, InvalidRequestErrorRep$inboundSchema), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(403, ForbiddenErrorRep$inboundSchema), jsonErr(404, NotFoundErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, FeatureFlags$inboundSchema), jsonErr(400, InvalidRequestErrorRep$inboundSchema), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(403, ForbiddenErrorRep$inboundSchema), jsonErr(404, NotFoundErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -39918,12 +41136,12 @@ var init_featureFlagsList = __esm(() => {
 });
 
 // src/mcp-server/tools/featureFlagsList.ts
-var args13, tool$featureFlagsList;
+var args15, tool$featureFlagsList;
 var init_featureFlagsList2 = __esm(() => {
   init_featureFlagsList();
   init_operations();
   init_tools();
-  args13 = {
+  args15 = {
     request: GetFeatureFlagsRequest$inboundSchema
   };
   tool$featureFlagsList = {
@@ -39931,9 +41149,9 @@ var init_featureFlagsList2 = __esm(() => {
     description: `Retrieves all feature flags within a project, including metadata and targeting rules. Enables AI agents to enumerate existing flags for inspection, configuration analysis, or generating flag usage reports across environments.
 `,
     scopes: ["read"],
-    args: args13,
-    tool: async (client, args14, ctx) => {
-      const [result, apiCall] = await featureFlagsList(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args15,
+    tool: async (client, args16, ctx) => {
+      const [result, apiCall] = await featureFlagsList(client, args16.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -39948,9 +41166,9 @@ var init_featureFlagsList2 = __esm(() => {
 
 // src/funcs/featureFlagsPatch.ts
 function featureFlagsPatch(client, request, options) {
-  return new APIPromise($do14(client, request, options));
+  return new APIPromise($do16(client, request, options));
 }
-async function $do14(client, request, options) {
+async function $do16(client, request, options) {
   const parsed = safeParse(request, (value) => PatchFeatureFlagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -40016,7 +41234,7 @@ async function $do14(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, FeatureFlag$inboundSchema), jsonErr(400, InvalidRequestErrorRep$inboundSchema), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(404, NotFoundErrorRep$inboundSchema), jsonErr(405, MethodNotAllowedErrorRep$inboundSchema), jsonErr(409, StatusConflictErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, FeatureFlag$inboundSchema), jsonErr(400, InvalidRequestErrorRep$inboundSchema), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(404, NotFoundErrorRep$inboundSchema), jsonErr(405, MethodNotAllowedErrorRep$inboundSchema), jsonErr(409, StatusConflictErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -40036,12 +41254,12 @@ var init_featureFlagsPatch = __esm(() => {
 });
 
 // src/mcp-server/tools/featureFlagsPatch.ts
-var args14, tool$featureFlagsPatch;
+var args16, tool$featureFlagsPatch;
 var init_featureFlagsPatch2 = __esm(() => {
   init_featureFlagsPatch();
   init_operations();
   init_tools();
-  args14 = {
+  args16 = {
     request: PatchFeatureFlagRequest$inboundSchema
   };
   tool$featureFlagsPatch = {
@@ -40049,9 +41267,9 @@ var init_featureFlagsPatch2 = __esm(() => {
     description: `Updates the configuration of an existing feature flag. Enables agents to change targeting rules, modify variations, or adapt rollout strategies dynamically in response to user behavior or experiment results.
 `,
     scopes: ["write"],
-    args: args14,
-    tool: async (client, args15, ctx) => {
-      const [result, apiCall] = await featureFlagsPatch(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args16,
+    tool: async (client, args17, ctx) => {
+      const [result, apiCall] = await featureFlagsPatch(client, args17.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -40068,7 +41286,7 @@ var init_featureFlagsPatch2 = __esm(() => {
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "LaunchDarkly",
-    version: "0.3.1"
+    version: "0.4.0"
   });
   const client = new LaunchDarklyCore({
     apiKey: deps.apiKey,
@@ -40087,6 +41305,8 @@ function createMCPServer(deps) {
   tool(tool$featureFlagsGet);
   tool(tool$featureFlagsPatch);
   tool(tool$featureFlagsDelete);
+  tool(tool$aiConfigsGetTargeting);
+  tool(tool$aiConfigsUpdateTargeting);
   tool(tool$aiConfigsList);
   tool(tool$aiConfigsCreate);
   tool(tool$aiConfigsDelete);
@@ -40108,9 +41328,11 @@ var init_server2 = __esm(() => {
   init_aiConfigsDelete2();
   init_aiConfigsDeleteVariation2();
   init_aiConfigsGet2();
+  init_aiConfigsGetTargeting2();
   init_aiConfigsGetVariation2();
   init_aiConfigsList2();
   init_aiConfigsUpdate2();
+  init_aiConfigsUpdateTargeting2();
   init_aiConfigsUpdateVariation2();
   init_featureFlagsCreate2();
   init_featureFlagsDelete2();
@@ -41234,15 +42456,13 @@ var startCommand = on({
           return stringType().parse(value);
         }
       },
-      ...mcpScopes.length ? {
-        scope: {
-          kind: "enum",
-          brief: "Mount tools/resources that match given scope (repeatable flag)",
-          values: mcpScopes,
-          variadic: true,
-          optional: true
-        }
-      } : {},
+      scope: {
+        kind: "enum",
+        brief: "Mount tools/resources that match given scope (repeatable flag)",
+        values: mcpScopes,
+        variadic: true,
+        optional: true
+      },
       "api-key": {
         kind: "parsed",
         brief: "Sets the apiKey auth field for the API",
@@ -41310,7 +42530,7 @@ var routes = an({
 var app = He(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.3.1"
+    currentVersion: "0.4.0"
   }
 });
 zt(app, process3.argv.slice(2), buildContext(process3));
@@ -41318,5 +42538,5 @@ export {
   app
 };
 
-//# debugId=39793AD8090FB23C64756E2164756E21
+//# debugId=8688EE4AC588B59B64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map