@unkey/api 2.1.0 → 2.1.2

package/bin/mcp-server.js

@@ -34085,8 +34085,231 @@ var init_mcp = __esm(() => {
   };
 });
 
+// src/lib/http.ts
+class HTTPClient {
+  options;
+  fetcher;
+  requestHooks = [];
+  requestErrorHooks = [];
+  responseHooks = [];
+  constructor(options = {}) {
+    this.options = options;
+    this.fetcher = options.fetcher || DEFAULT_FETCHER;
+  }
+  async request(request) {
+    let req = request;
+    for (const hook of this.requestHooks) {
+      const nextRequest = await hook(req);
+      if (nextRequest) {
+        req = nextRequest;
+      }
+    }
+    try {
+      const res = await this.fetcher(req);
+      for (const hook of this.responseHooks) {
+        await hook(res, req);
+      }
+      return res;
+    } catch (err) {
+      for (const hook of this.requestErrorHooks) {
+        await hook(err, req);
+      }
+      throw err;
+    }
+  }
+  addHook(...args) {
+    if (args[0] === "beforeRequest") {
+      this.requestHooks.push(args[1]);
+    } else if (args[0] === "requestError") {
+      this.requestErrorHooks.push(args[1]);
+    } else if (args[0] === "response") {
+      this.responseHooks.push(args[1]);
+    } else {
+      throw new Error(`Invalid hook type: ${args[0]}`);
+    }
+    return this;
+  }
+  removeHook(...args) {
+    let target;
+    if (args[0] === "beforeRequest") {
+      target = this.requestHooks;
+    } else if (args[0] === "requestError") {
+      target = this.requestErrorHooks;
+    } else if (args[0] === "response") {
+      target = this.responseHooks;
+    } else {
+      throw new Error(`Invalid hook type: ${args[0]}`);
+    }
+    const index = target.findIndex((v2) => v2 === args[1]);
+    if (index >= 0) {
+      target.splice(index, 1);
+    }
+    return this;
+  }
+  clone() {
+    const child = new HTTPClient(this.options);
+    child.requestHooks = this.requestHooks.slice();
+    child.requestErrorHooks = this.requestErrorHooks.slice();
+    child.responseHooks = this.responseHooks.slice();
+    return child;
+  }
+}
+function matchContentType(response, pattern) {
+  if (pattern === "*") {
+    return true;
+  }
+  let contentType2 = response.headers.get("content-type")?.trim() || "application/octet-stream";
+  contentType2 = contentType2.toLowerCase();
+  const wantParts = pattern.toLowerCase().trim().split(mediaParamSeparator);
+  const [wantType = "", ...wantParams] = wantParts;
+  if (wantType.split("/").length !== 2) {
+    return false;
+  }
+  const gotParts = contentType2.split(mediaParamSeparator);
+  const [gotType = "", ...gotParams] = gotParts;
+  const [type = "", subtype = ""] = gotType.split("/");
+  if (!type || !subtype) {
+    return false;
+  }
+  if (wantType !== "*/*" && gotType !== wantType && `${type}/*` !== wantType && `*/${subtype}` !== wantType) {
+    return false;
+  }
+  if (gotParams.length < wantParams.length) {
+    return false;
+  }
+  const params = new Set(gotParams);
+  for (const wantParam of wantParams) {
+    if (!params.has(wantParam)) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchStatusCode(response, codes) {
+  const actual = `${response.status}`;
+  const expectedCodes = Array.isArray(codes) ? codes : [codes];
+  if (!expectedCodes.length) {
+    return false;
+  }
+  return expectedCodes.some((ec) => {
+    const code = `${ec}`;
+    if (code === "default") {
+      return true;
+    }
+    if (!codeRangeRE.test(`${code}`)) {
+      return code === actual;
+    }
+    const expectFamily = code.charAt(0);
+    if (!expectFamily) {
+      throw new Error("Invalid status code range");
+    }
+    const actualFamily = actual.charAt(0);
+    if (!actualFamily) {
+      throw new Error(`Invalid response status code: ${actual}`);
+    }
+    return actualFamily === expectFamily;
+  });
+}
+function matchResponse(response, code, contentTypePattern) {
+  return matchStatusCode(response, code) && matchContentType(response, contentTypePattern);
+}
+function isConnectionError(err) {
+  if (typeof err !== "object" || err == null) {
+    return false;
+  }
+  const isBrowserErr = err instanceof TypeError && err.message.toLowerCase().startsWith("failed to fetch");
+  const isNodeErr = err instanceof TypeError && err.message.toLowerCase().startsWith("fetch failed");
+  const isBunErr = "name" in err && err.name === "ConnectionError";
+  const isGenericErr = "code" in err && typeof err.code === "string" && err.code.toLowerCase() === "econnreset";
+  return isBrowserErr || isNodeErr || isGenericErr || isBunErr;
+}
+function isTimeoutError(err) {
+  if (typeof err !== "object" || err == null) {
+    return false;
+  }
+  const isNative = "name" in err && err.name === "TimeoutError";
+  const isLegacyNative = "code" in err && err.code === 23;
+  const isGenericErr = "code" in err && typeof err.code === "string" && err.code.toLowerCase() === "econnaborted";
+  return isNative || isLegacyNative || isGenericErr;
+}
+function isAbortError(err) {
+  if (typeof err !== "object" || err == null) {
+    return false;
+  }
+  const isNative = "name" in err && err.name === "AbortError";
+  const isLegacyNative = "code" in err && err.code === 20;
+  const isGenericErr = "code" in err && typeof err.code === "string" && err.code.toLowerCase() === "econnaborted";
+  return isNative || isLegacyNative || isGenericErr;
+}
+var DEFAULT_FETCHER = (input, init) => {
+  if (init == null) {
+    return fetch(input);
+  } else {
+    return fetch(input, init);
+  }
+}, mediaParamSeparator, codeRangeRE;
+var init_http = __esm(() => {
+  mediaParamSeparator = /\s*;\s*/g;
+  codeRangeRE = new RegExp("^[0-9]xx$", "i");
+});
+
+// src/hooks/custom/vercel-edge-fetcher.ts
+function isVercelEdgeRuntime() {
+  if ("EdgeRuntime" in globalThis)
+    return true;
+  if (process.env["NEXT_RUNTIME"] === "edge")
+    return true;
+  return false;
+}
+
+class FetcherOverrideForVercelEdgeHook {
+  sdkInit(opts) {
+    if (!isVercelEdgeRuntime()) {
+      return opts;
+    }
+    const client = new HTTPClient({
+      fetcher: vercelEdgeFetcher
+    });
+    return {
+      ...opts,
+      client
+    };
+  }
+}
+var vercelEdgeFetcher = (input, init) => {
+  const isRequestLike = typeof input === "object" && input !== null && "url" in input && "method" in input && "headers" in input;
+  if (isRequestLike && !init) {
+    const req = input;
+    return fetch(req.url, {
+      method: req.method,
+      headers: req.headers,
+      body: req.body,
+      mode: req.mode,
+      credentials: req.credentials,
+      cache: req.cache,
+      redirect: req.redirect,
+      referrer: req.referrer,
+      integrity: req.integrity,
+      signal: req.signal
+    });
+  }
+  if (init == null) {
+    return fetch(input);
+  } else {
+    return fetch(input, init);
+  }
+};
+var init_vercel_edge_fetcher = __esm(() => {
+  init_http();
+});
+
 // src/hooks/registration.ts
-function initHooks(hooks) {}
+function initHooks(hooks) {
+  hooks.registerSDKInitHook(new FetcherOverrideForVercelEdgeHook);
+}
+var init_registration = __esm(() => {
+  init_vercel_edge_fetcher();
+});
 
 // src/hooks/hooks.ts
 class SDKHooks {
@@ -34166,7 +34389,9 @@ class SDKHooks {
     return { response: res, error: err };
   }
 }
-var init_hooks = () => {};
+var init_hooks = __esm(() => {
+  init_registration();
+});
 
 // src/models/errors/httpclienterrors.ts
 var HTTPClientError, UnexpectedClientError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, ConnectionError;
@@ -34274,9 +34499,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "2.0.0",
-    sdkVersion: "2.1.0",
-    genVersion: "2.743.9",
-    userAgent: "speakeasy-sdk/typescript 2.1.0 2.743.9 2.0.0 @unkey/api"
+    sdkVersion: "2.1.2",
+    genVersion: "2.753.6",
+    userAgent: "speakeasy-sdk/typescript 2.1.2 2.753.6 2.0.0 @unkey/api"
   };
 });
 
@@ -34494,186 +34719,18 @@ function env() {
   if (isDeno()) {
     envObject = globalThis.Deno?.env?.toObject?.() ?? {};
   } else {
-    envObject = dlv(globalThis, "process.env") ?? {};
-  }
-  envMemo = envSchema.parse(envObject);
-  return envMemo;
-}
-var envSchema, envMemo = undefined;
-var init_env = __esm(() => {
-  init_v3();
-  envSchema = objectType({
-    UNKEY_ROOT_KEY: stringType().optional(),
-    UNKEY_DEBUG: coerce.boolean().optional()
-  });
-});
-
-// src/lib/http.ts
-class HTTPClient {
-  options;
-  fetcher;
-  requestHooks = [];
-  requestErrorHooks = [];
-  responseHooks = [];
-  constructor(options = {}) {
-    this.options = options;
-    this.fetcher = options.fetcher || DEFAULT_FETCHER;
-  }
-  async request(request) {
-    let req = request;
-    for (const hook of this.requestHooks) {
-      const nextRequest = await hook(req);
-      if (nextRequest) {
-        req = nextRequest;
-      }
-    }
-    try {
-      const res = await this.fetcher(req);
-      for (const hook of this.responseHooks) {
-        await hook(res, req);
-      }
-      return res;
-    } catch (err) {
-      for (const hook of this.requestErrorHooks) {
-        await hook(err, req);
-      }
-      throw err;
-    }
-  }
-  addHook(...args) {
-    if (args[0] === "beforeRequest") {
-      this.requestHooks.push(args[1]);
-    } else if (args[0] === "requestError") {
-      this.requestErrorHooks.push(args[1]);
-    } else if (args[0] === "response") {
-      this.responseHooks.push(args[1]);
-    } else {
-      throw new Error(`Invalid hook type: ${args[0]}`);
-    }
-    return this;
-  }
-  removeHook(...args) {
-    let target;
-    if (args[0] === "beforeRequest") {
-      target = this.requestHooks;
-    } else if (args[0] === "requestError") {
-      target = this.requestErrorHooks;
-    } else if (args[0] === "response") {
-      target = this.responseHooks;
-    } else {
-      throw new Error(`Invalid hook type: ${args[0]}`);
-    }
-    const index = target.findIndex((v2) => v2 === args[1]);
-    if (index >= 0) {
-      target.splice(index, 1);
-    }
-    return this;
-  }
-  clone() {
-    const child = new HTTPClient(this.options);
-    child.requestHooks = this.requestHooks.slice();
-    child.requestErrorHooks = this.requestErrorHooks.slice();
-    child.responseHooks = this.responseHooks.slice();
-    return child;
-  }
-}
-function matchContentType(response, pattern) {
-  if (pattern === "*") {
-    return true;
-  }
-  let contentType2 = response.headers.get("content-type")?.trim() || "application/octet-stream";
-  contentType2 = contentType2.toLowerCase();
-  const wantParts = pattern.toLowerCase().trim().split(mediaParamSeparator);
-  const [wantType = "", ...wantParams] = wantParts;
-  if (wantType.split("/").length !== 2) {
-    return false;
-  }
-  const gotParts = contentType2.split(mediaParamSeparator);
-  const [gotType = "", ...gotParams] = gotParts;
-  const [type = "", subtype = ""] = gotType.split("/");
-  if (!type || !subtype) {
-    return false;
-  }
-  if (wantType !== "*/*" && gotType !== wantType && `${type}/*` !== wantType && `*/${subtype}` !== wantType) {
-    return false;
-  }
-  if (gotParams.length < wantParams.length) {
-    return false;
-  }
-  const params = new Set(gotParams);
-  for (const wantParam of wantParams) {
-    if (!params.has(wantParam)) {
-      return false;
-    }
-  }
-  return true;
-}
-function matchStatusCode(response, codes) {
-  const actual = `${response.status}`;
-  const expectedCodes = Array.isArray(codes) ? codes : [codes];
-  if (!expectedCodes.length) {
-    return false;
-  }
-  return expectedCodes.some((ec) => {
-    const code = `${ec}`;
-    if (code === "default") {
-      return true;
-    }
-    if (!codeRangeRE.test(`${code}`)) {
-      return code === actual;
-    }
-    const expectFamily = code.charAt(0);
-    if (!expectFamily) {
-      throw new Error("Invalid status code range");
-    }
-    const actualFamily = actual.charAt(0);
-    if (!actualFamily) {
-      throw new Error(`Invalid response status code: ${actual}`);
-    }
-    return actualFamily === expectFamily;
-  });
-}
-function matchResponse(response, code, contentTypePattern) {
-  return matchStatusCode(response, code) && matchContentType(response, contentTypePattern);
-}
-function isConnectionError(err) {
-  if (typeof err !== "object" || err == null) {
-    return false;
-  }
-  const isBrowserErr = err instanceof TypeError && err.message.toLowerCase().startsWith("failed to fetch");
-  const isNodeErr = err instanceof TypeError && err.message.toLowerCase().startsWith("fetch failed");
-  const isBunErr = "name" in err && err.name === "ConnectionError";
-  const isGenericErr = "code" in err && typeof err.code === "string" && err.code.toLowerCase() === "econnreset";
-  return isBrowserErr || isNodeErr || isGenericErr || isBunErr;
-}
-function isTimeoutError(err) {
-  if (typeof err !== "object" || err == null) {
-    return false;
-  }
-  const isNative = "name" in err && err.name === "TimeoutError";
-  const isLegacyNative = "code" in err && err.code === 23;
-  const isGenericErr = "code" in err && typeof err.code === "string" && err.code.toLowerCase() === "econnaborted";
-  return isNative || isLegacyNative || isGenericErr;
-}
-function isAbortError(err) {
-  if (typeof err !== "object" || err == null) {
-    return false;
-  }
-  const isNative = "name" in err && err.name === "AbortError";
-  const isLegacyNative = "code" in err && err.code === 20;
-  const isGenericErr = "code" in err && typeof err.code === "string" && err.code.toLowerCase() === "econnaborted";
-  return isNative || isLegacyNative || isGenericErr;
-}
-var DEFAULT_FETCHER = (input, init) => {
-  if (init == null) {
-    return fetch(input);
-  } else {
-    return fetch(input, init);
+    envObject = dlv(globalThis, "process.env") ?? {};
   }
-}, mediaParamSeparator, codeRangeRE;
-var init_http = __esm(() => {
-  mediaParamSeparator = /\s*;\s*/g;
-  codeRangeRE = new RegExp("^[0-9]xx$", "i");
+  envMemo = envSchema.parse(envObject);
+  return envMemo;
+}
+var envSchema, envMemo = undefined;
+var init_env = __esm(() => {
+  init_v3();
+  envSchema = objectType({
+    UNKEY_ROOT_KEY: stringType().optional(),
+    UNKEY_DEBUG: coerce.boolean().optional()
+  });
 });
 
 // src/lib/retries.ts
@@ -36609,6 +36666,100 @@ var init_v2keysgetkeyresponsebody = __esm(() => {
   });
 });
 
+// src/models/components/v2keysmigratekeydata.ts
+var V2KeysMigrateKeyData$inboundSchema, V2KeysMigrateKeyData$outboundSchema;
+var init_v2keysmigratekeydata = __esm(() => {
+  init_v3();
+  init_keycreditsdata();
+  init_ratelimitrequest();
+  V2KeysMigrateKeyData$inboundSchema = objectType({
+    hash: stringType(),
+    name: stringType().optional(),
+    externalId: stringType().optional(),
+    meta: recordType(anyType()).optional(),
+    roles: arrayType(stringType()).optional(),
+    permissions: arrayType(stringType()).optional(),
+    expires: numberType().int().optional(),
+    enabled: booleanType().default(true),
+    credits: KeyCreditsData$inboundSchema.optional(),
+    ratelimits: arrayType(RatelimitRequest$inboundSchema).optional()
+  });
+  V2KeysMigrateKeyData$outboundSchema = objectType({
+    hash: stringType(),
+    name: stringType().optional(),
+    externalId: stringType().optional(),
+    meta: recordType(anyType()).optional(),
+    roles: arrayType(stringType()).optional(),
+    permissions: arrayType(stringType()).optional(),
+    expires: numberType().int().optional(),
+    enabled: booleanType().default(true),
+    credits: KeyCreditsData$outboundSchema.optional(),
+    ratelimits: arrayType(RatelimitRequest$outboundSchema).optional()
+  });
+});
+
+// src/models/components/v2keysmigratekeysmigration.ts
+var V2KeysMigrateKeysMigration$inboundSchema, V2KeysMigrateKeysMigration$outboundSchema;
+var init_v2keysmigratekeysmigration = __esm(() => {
+  init_v3();
+  V2KeysMigrateKeysMigration$inboundSchema = objectType({
+    hash: stringType(),
+    keyId: stringType()
+  });
+  V2KeysMigrateKeysMigration$outboundSchema = objectType({
+    hash: stringType(),
+    keyId: stringType()
+  });
+});
+
+// src/models/components/v2keysmigratekeysrequestbody.ts
+var V2KeysMigrateKeysRequestBody$inboundSchema, V2KeysMigrateKeysRequestBody$outboundSchema;
+var init_v2keysmigratekeysrequestbody = __esm(() => {
+  init_v3();
+  init_v2keysmigratekeydata();
+  V2KeysMigrateKeysRequestBody$inboundSchema = objectType({
+    migrationId: stringType(),
+    apiId: stringType(),
+    keys: arrayType(V2KeysMigrateKeyData$inboundSchema)
+  });
+  V2KeysMigrateKeysRequestBody$outboundSchema = objectType({
+    migrationId: stringType(),
+    apiId: stringType(),
+    keys: arrayType(V2KeysMigrateKeyData$outboundSchema)
+  });
+});
+
+// src/models/components/v2keysmigratekeysresponsedata.ts
+var V2KeysMigrateKeysResponseData$inboundSchema, V2KeysMigrateKeysResponseData$outboundSchema;
+var init_v2keysmigratekeysresponsedata = __esm(() => {
+  init_v3();
+  init_v2keysmigratekeysmigration();
+  V2KeysMigrateKeysResponseData$inboundSchema = objectType({
+    migrated: arrayType(V2KeysMigrateKeysMigration$inboundSchema),
+    failed: arrayType(stringType())
+  });
+  V2KeysMigrateKeysResponseData$outboundSchema = objectType({
+    migrated: arrayType(V2KeysMigrateKeysMigration$outboundSchema),
+    failed: arrayType(stringType())
+  });
+});
+
+// src/models/components/v2keysmigratekeysresponsebody.ts
+var V2KeysMigrateKeysResponseBody$inboundSchema, V2KeysMigrateKeysResponseBody$outboundSchema;
+var init_v2keysmigratekeysresponsebody = __esm(() => {
+  init_v3();
+  init_meta();
+  init_v2keysmigratekeysresponsedata();
+  V2KeysMigrateKeysResponseBody$inboundSchema = objectType({
+    meta: Meta$inboundSchema,
+    data: V2KeysMigrateKeysResponseData$inboundSchema
+  });
+  V2KeysMigrateKeysResponseBody$outboundSchema = objectType({
+    meta: Meta$outboundSchema,
+    data: V2KeysMigrateKeysResponseData$outboundSchema
+  });
+});
+
 // src/models/components/v2keysremovepermissionsrequestbody.ts
 var V2KeysRemovePermissionsRequestBody$inboundSchema, V2KeysRemovePermissionsRequestBody$outboundSchema;
 var init_v2keysremovepermissionsrequestbody = __esm(() => {
@@ -36871,14 +37022,16 @@ var init_v2keysverifykeyrequestbody = __esm(() => {
     tags: arrayType(stringType()).optional(),
     permissions: stringType().optional(),
     credits: KeysVerifyKeyCredits$inboundSchema.optional(),
-    ratelimits: arrayType(KeysVerifyKeyRatelimit$inboundSchema).optional()
+    ratelimits: arrayType(KeysVerifyKeyRatelimit$inboundSchema).optional(),
+    migrationId: stringType().optional()
   });
   V2KeysVerifyKeyRequestBody$outboundSchema = objectType({
     key: stringType(),
     tags: arrayType(stringType()).optional(),
     permissions: stringType().optional(),
     credits: KeysVerifyKeyCredits$outboundSchema.optional(),
-    ratelimits: arrayType(KeysVerifyKeyRatelimit$outboundSchema).optional()
+    ratelimits: arrayType(KeysVerifyKeyRatelimit$outboundSchema).optional(),
+    migrationId: stringType().optional()
   });
 });
 
@@ -37424,6 +37577,61 @@ var init_v2ratelimitlistoverridesresponsebody = __esm(() => {
   });
 });
 
+// src/models/components/v2ratelimitmultilimitcheck.ts
+var V2RatelimitMultiLimitCheck$inboundSchema, V2RatelimitMultiLimitCheck$outboundSchema;
+var init_v2ratelimitmultilimitcheck = __esm(() => {
+  init_v3();
+  V2RatelimitMultiLimitCheck$inboundSchema = objectType({
+    namespace: stringType(),
+    identifier: stringType(),
+    limit: numberType().int(),
+    remaining: numberType().int(),
+    reset: numberType().int(),
+    passed: booleanType(),
+    overrideId: stringType().optional()
+  });
+  V2RatelimitMultiLimitCheck$outboundSchema = objectType({
+    namespace: stringType(),
+    identifier: stringType(),
+    limit: numberType().int(),
+    remaining: numberType().int(),
+    reset: numberType().int(),
+    passed: booleanType(),
+    overrideId: stringType().optional()
+  });
+});
+
+// src/models/components/v2ratelimitmultilimitresponsedata.ts
+var V2RatelimitMultiLimitResponseData$inboundSchema, V2RatelimitMultiLimitResponseData$outboundSchema;
+var init_v2ratelimitmultilimitresponsedata = __esm(() => {
+  init_v3();
+  init_v2ratelimitmultilimitcheck();
+  V2RatelimitMultiLimitResponseData$inboundSchema = objectType({
+    passed: booleanType(),
+    limits: arrayType(V2RatelimitMultiLimitCheck$inboundSchema)
+  });
+  V2RatelimitMultiLimitResponseData$outboundSchema = objectType({
+    passed: booleanType(),
+    limits: arrayType(V2RatelimitMultiLimitCheck$outboundSchema)
+  });
+});
+
+// src/models/components/v2ratelimitmultilimitresponsebody.ts
+var V2RatelimitMultiLimitResponseBody$inboundSchema, V2RatelimitMultiLimitResponseBody$outboundSchema;
+var init_v2ratelimitmultilimitresponsebody = __esm(() => {
+  init_v3();
+  init_meta();
+  init_v2ratelimitmultilimitresponsedata();
+  V2RatelimitMultiLimitResponseBody$inboundSchema = objectType({
+    meta: Meta$inboundSchema,
+    data: V2RatelimitMultiLimitResponseData$inboundSchema
+  });
+  V2RatelimitMultiLimitResponseBody$outboundSchema = objectType({
+    meta: Meta$outboundSchema,
+    data: V2RatelimitMultiLimitResponseData$outboundSchema
+  });
+});
+
 // src/models/components/v2ratelimitsetoverriderequestbody.ts
 var V2RatelimitSetOverrideRequestBody$inboundSchema, V2RatelimitSetOverrideRequestBody$outboundSchema;
 var init_v2ratelimitsetoverriderequestbody = __esm(() => {
@@ -37525,6 +37733,11 @@ var init_components = __esm(() => {
   init_v2keysdeletekeyresponsebody();
   init_v2keysgetkeyrequestbody();
   init_v2keysgetkeyresponsebody();
+  init_v2keysmigratekeydata();
+  init_v2keysmigratekeysmigration();
+  init_v2keysmigratekeysrequestbody();
+  init_v2keysmigratekeysresponsebody();
+  init_v2keysmigratekeysresponsedata();
   init_v2keysremovepermissionsrequestbody();
   init_v2keysremovepermissionsresponsebody();
   init_v2keysremoverolesrequestbody();
@@ -37573,6 +37786,9 @@ var init_components = __esm(() => {
   init_v2ratelimitlimitresponsedata();
   init_v2ratelimitlistoverridesrequestbody();
   init_v2ratelimitlistoverridesresponsebody();
+  init_v2ratelimitmultilimitcheck();
+  init_v2ratelimitmultilimitresponsebody();
+  init_v2ratelimitmultilimitresponsedata();
   init_v2ratelimitsetoverriderequestbody();
   init_v2ratelimitsetoverrideresponsebody();
   init_v2ratelimitsetoverrideresponsedata();
@@ -39986,11 +40202,129 @@ Additional permission required for decrypt functionality:
   };
 });
 
-// src/funcs/keysRemovePermissions.ts
-function keysRemovePermissions(client, request, options) {
+// src/funcs/keysMigrateKeys.ts
+function keysMigrateKeys(client, request, options) {
   return new APIPromise($do16(client, request, options));
 }
 async function $do16(client, request, options) {
+  const parsed = safeParse(request, (value) => V2KeysMigrateKeysRequestBody$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/v2/keys.migrateKeys")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.rootKey);
+  const securityInput = secConfig == null ? {} : { rootKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "migrateKeys",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.rootKey,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 50,
+        maxInterval: 1000,
+        exponent: 1.5,
+        maxElapsedTime: 1e4
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    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", "401", "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, V2KeysMigrateKeysResponseBody$inboundSchema), jsonErr(400, BadRequestErrorResponse$inboundSchema), jsonErr(401, UnauthorizedErrorResponse$inboundSchema), jsonErr(403, ForbiddenErrorResponse$inboundSchema), jsonErr(404, NotFoundErrorResponse$inboundSchema), jsonErr(500, InternalServerErrorResponse$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_keysMigrateKeys = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_async();
+});
+
+// src/mcp-server/tools/keysMigrateKeys.ts
+var args16, tool$keysMigrateKeys;
+var init_keysMigrateKeys2 = __esm(() => {
+  init_keysMigrateKeys();
+  init_components();
+  init_tools();
+  args16 = {
+    request: V2KeysMigrateKeysRequestBody$inboundSchema
+  };
+  tool$keysMigrateKeys = {
+    name: "keys-migrate-keys",
+    description: `Migrate API key(s)
+
+Returns HTTP 200 even on partial success; hashes that could not be migrated are listed under \`data.failed\`.
+
+**Required Permissions**
+Your root key must have one of the following permissions for basic key information:
+- \`api.*.create_key\` (to migrate keys to any API)
+- \`api.<api_id>.create_key\` (to migrate keys to a specific API)
+`,
+    args: args16,
+    tool: async (client, args17, ctx) => {
+      const [result, apiCall] = await keysMigrateKeys(client, args17.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/keysRemovePermissions.ts
+function keysRemovePermissions(client, request, options) {
+  return new APIPromise($do17(client, request, options));
+}
+async function $do17(client, request, options) {
   const parsed = safeParse(request, (value) => V2KeysRemovePermissionsRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -40070,12 +40404,12 @@ var init_keysRemovePermissions = __esm(() => {
 });
 
 // src/mcp-server/tools/keysRemovePermissions.ts
-var args16, tool$keysRemovePermissions;
+var args17, tool$keysRemovePermissions;
 var init_keysRemovePermissions2 = __esm(() => {
   init_keysRemovePermissions();
   init_components();
   init_tools();
-  args16 = {
+  args17 = {
     request: V2KeysRemovePermissionsRequestBody$inboundSchema
   };
   tool$keysRemovePermissions = {
@@ -40098,9 +40432,9 @@ Your root key must have one of the following permissions:
 
 Invalidates the key cache for immediate effect, and makes permission changes available for verification within 30 seconds across all regions.
 `,
-    args: args16,
-    tool: async (client, args17, ctx) => {
-      const [result, apiCall] = await keysRemovePermissions(client, args17.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args17,
+    tool: async (client, args18, ctx) => {
+      const [result, apiCall] = await keysRemovePermissions(client, args18.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -40115,9 +40449,9 @@ Invalidates the key cache for immediate effect, and makes permission changes ava
 
 // src/funcs/keysRemoveRoles.ts
 function keysRemoveRoles(client, request, options) {
-  return new APIPromise($do17(client, request, options));
+  return new APIPromise($do18(client, request, options));
 }
-async function $do17(client, request, options) {
+async function $do18(client, request, options) {
   const parsed = safeParse(request, (value) => V2KeysRemoveRolesRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -40197,12 +40531,12 @@ var init_keysRemoveRoles = __esm(() => {
 });
 
 // src/mcp-server/tools/keysRemoveRoles.ts
-var args17, tool$keysRemoveRoles;
+var args18, tool$keysRemoveRoles;
 var init_keysRemoveRoles2 = __esm(() => {
   init_keysRemoveRoles();
   init_components();
   init_tools();
-  args17 = {
+  args18 = {
     request: V2KeysRemoveRolesRequestBody$inboundSchema
   };
   tool$keysRemoveRoles = {
@@ -40225,9 +40559,9 @@ Your root key must have one of the following permissions:
 
 Invalidates the key cache for immediate effect, and makes role changes available for verification within 30 seconds across all regions.
 `,
-    args: args17,
-    tool: async (client, args18, ctx) => {
-      const [result, apiCall] = await keysRemoveRoles(client, args18.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args18,
+    tool: async (client, args19, ctx) => {
+      const [result, apiCall] = await keysRemoveRoles(client, args19.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -40242,9 +40576,9 @@ Invalidates the key cache for immediate effect, and makes role changes available
 
 // src/funcs/keysRerollKey.ts
 function keysRerollKey(client, request, options) {
-  return new APIPromise($do18(client, request, options));
+  return new APIPromise($do19(client, request, options));
 }
-async function $do18(client, request, options) {
+async function $do19(client, request, options) {
   const parsed = safeParse(request, (value) => V2KeysRerollKeyRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -40324,12 +40658,12 @@ var init_keysRerollKey = __esm(() => {
 });
 
 // src/mcp-server/tools/keysRerollKey.ts
-var args18, tool$keysRerollKey;
+var args19, tool$keysRerollKey;
 var init_keysRerollKey2 = __esm(() => {
   init_keysRerollKey();
   init_components();
   init_tools();
-  args18 = {
+  args19 = {
     request: V2KeysRerollKeyRequestBody$inboundSchema
   };
   tool$keysRerollKey = {
@@ -40369,9 +40703,9 @@ Common use cases include:
  - \`api.*.create_key\` or \`api.<api_id>.create_key\`
  - \`api.*.encrypt_key\` or \`api.<api_id>.encrypt_key\` (only when the original key is recoverable)
 `,
-    args: args18,
-    tool: async (client, args19, ctx) => {
-      const [result, apiCall] = await keysRerollKey(client, args19.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args19,
+    tool: async (client, args20, ctx) => {
+      const [result, apiCall] = await keysRerollKey(client, args20.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -40386,9 +40720,9 @@ Common use cases include:
 
 // src/funcs/keysSetPermissions.ts
 function keysSetPermissions(client, request, options) {
-  return new APIPromise($do19(client, request, options));
+  return new APIPromise($do20(client, request, options));
 }
-async function $do19(client, request, options) {
+async function $do20(client, request, options) {
   const parsed = safeParse(request, (value) => V2KeysSetPermissionsRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -40468,12 +40802,12 @@ var init_keysSetPermissions = __esm(() => {
 });
 
 // src/mcp-server/tools/keysSetPermissions.ts
-var args19, tool$keysSetPermissions;
+var args20, tool$keysSetPermissions;
 var init_keysSetPermissions2 = __esm(() => {
   init_keysSetPermissions();
   init_components();
   init_tools();
-  args19 = {
+  args20 = {
     request: V2KeysSetPermissionsRequestBody$inboundSchema
   };
   tool$keysSetPermissions = {
@@ -40496,9 +40830,9 @@ Your root key must have one of the following permissions:
 
 Invalidates the key cache for immediate effect, and makes permission changes available for verification within 30 seconds across all regions.
 `,
-    args: args19,
-    tool: async (client, args20, ctx) => {
-      const [result, apiCall] = await keysSetPermissions(client, args20.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args20,
+    tool: async (client, args21, ctx) => {
+      const [result, apiCall] = await keysSetPermissions(client, args21.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -40513,9 +40847,9 @@ Invalidates the key cache for immediate effect, and makes permission changes ava
 
 // src/funcs/keysSetRoles.ts
 function keysSetRoles(client, request, options) {
-  return new APIPromise($do20(client, request, options));
+  return new APIPromise($do21(client, request, options));
 }
-async function $do20(client, request, options) {
+async function $do21(client, request, options) {
   const parsed = safeParse(request, (value) => V2KeysSetRolesRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -40595,12 +40929,12 @@ var init_keysSetRoles = __esm(() => {
 });
 
 // src/mcp-server/tools/keysSetRoles.ts
-var args20, tool$keysSetRoles;
+var args21, tool$keysSetRoles;
 var init_keysSetRoles2 = __esm(() => {
   init_keysSetRoles();
   init_components();
   init_tools();
-  args20 = {
+  args21 = {
     request: V2KeysSetRolesRequestBody$inboundSchema
   };
   tool$keysSetRoles = {
@@ -40623,9 +40957,9 @@ Your root key must have one of the following permissions:
 
 Invalidates the key cache for immediate effect, and makes role changes available for verification within 30 seconds across all regions.
 `,
-    args: args20,
-    tool: async (client, args21, ctx) => {
-      const [result, apiCall] = await keysSetRoles(client, args21.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args21,
+    tool: async (client, args22, ctx) => {
+      const [result, apiCall] = await keysSetRoles(client, args22.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -40640,9 +40974,9 @@ Invalidates the key cache for immediate effect, and makes role changes available
 
 // src/funcs/keysUpdateCredits.ts
 function keysUpdateCredits(client, request, options) {
-  return new APIPromise($do21(client, request, options));
+  return new APIPromise($do22(client, request, options));
 }
-async function $do21(client, request, options) {
+async function $do22(client, request, options) {
   const parsed = safeParse(request, (value) => V2KeysUpdateCreditsRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -40722,12 +41056,12 @@ var init_keysUpdateCredits = __esm(() => {
 });
 
 // src/mcp-server/tools/keysUpdateCredits.ts
-var args21, tool$keysUpdateCredits;
+var args22, tool$keysUpdateCredits;
 var init_keysUpdateCredits2 = __esm(() => {
   init_keysUpdateCredits();
   init_components();
   init_tools();
-  args21 = {
+  args22 = {
     request: V2KeysUpdateCreditsRequestBody$inboundSchema
   };
   tool$keysUpdateCredits = {
@@ -40750,9 +41084,9 @@ Your root key must have one of the following permissions:
 
 Credit updates remove the key from cache immediately. Setting credits to unlimited automatically clears any existing refill settings. Changes take effect instantly but may take up to 30 seconds to propagate to all edge regions.
 `,
-    args: args21,
-    tool: async (client, args22, ctx) => {
-      const [result, apiCall] = await keysUpdateCredits(client, args22.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args22,
+    tool: async (client, args23, ctx) => {
+      const [result, apiCall] = await keysUpdateCredits(client, args23.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -40767,9 +41101,9 @@ Credit updates remove the key from cache immediately. Setting credits to unlimit
 
 // src/funcs/keysUpdateKey.ts
 function keysUpdateKey(client, request, options) {
-  return new APIPromise($do22(client, request, options));
+  return new APIPromise($do23(client, request, options));
 }
-async function $do22(client, request, options) {
+async function $do23(client, request, options) {
   const parsed = safeParse(request, (value) => V2KeysUpdateKeyRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -40849,12 +41183,12 @@ var init_keysUpdateKey = __esm(() => {
 });
 
 // src/mcp-server/tools/keysUpdateKey.ts
-var args22, tool$keysUpdateKey;
+var args23, tool$keysUpdateKey;
 var init_keysUpdateKey2 = __esm(() => {
   init_keysUpdateKey();
   init_components();
   init_tools();
-  args22 = {
+  args23 = {
     request: V2KeysUpdateKeyRequestBody$inboundSchema
   };
   tool$keysUpdateKey = {
@@ -40877,9 +41211,9 @@ Your root key must have one of the following permissions:
 
 If you specify an \`externalId\` that doesn't exist, a new identity will be automatically created and linked to the key. Permission updates will auto-create any permissions that don't exist in your workspace. Changes take effect immediately but may take up to 30 seconds to propagate to all edge regions due to cache invalidation.
 `,
-    args: args22,
-    tool: async (client, args23, ctx) => {
-      const [result, apiCall] = await keysUpdateKey(client, args23.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args23,
+    tool: async (client, args24, ctx) => {
+      const [result, apiCall] = await keysUpdateKey(client, args24.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -40894,9 +41228,9 @@ If you specify an \`externalId\` that doesn't exist, a new identity will be auto
 
 // src/funcs/keysVerifyKey.ts
 function keysVerifyKey(client, request, options) {
-  return new APIPromise($do23(client, request, options));
+  return new APIPromise($do24(client, request, options));
 }
-async function $do23(client, request, options) {
+async function $do24(client, request, options) {
   const parsed = safeParse(request, (value) => V2KeysVerifyKeyRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -40976,12 +41310,12 @@ var init_keysVerifyKey = __esm(() => {
 });
 
 // src/mcp-server/tools/keysVerifyKey.ts
-var args23, tool$keysVerifyKey;
+var args24, tool$keysVerifyKey;
 var init_keysVerifyKey2 = __esm(() => {
   init_keysVerifyKey();
   init_components();
   init_tools();
-  args23 = {
+  args24 = {
     request: V2KeysVerifyKeyRequestBody$inboundSchema
   };
   tool$keysVerifyKey = {
@@ -41007,9 +41341,9 @@ Your root key needs one of:
 
 If you are getting a NOT_FOUND error, ensure your root key has the required verify key permissions.
 `,
-    args: args23,
-    tool: async (client, args24, ctx) => {
-      const [result, apiCall] = await keysVerifyKey(client, args24.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args24,
+    tool: async (client, args25, ctx) => {
+      const [result, apiCall] = await keysVerifyKey(client, args25.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41024,9 +41358,9 @@ If you are getting a NOT_FOUND error, ensure your root key has the required veri
 
 // src/funcs/keysWhoami.ts
 function keysWhoami(client, request, options) {
-  return new APIPromise($do24(client, request, options));
+  return new APIPromise($do25(client, request, options));
 }
-async function $do24(client, request, options) {
+async function $do25(client, request, options) {
   const parsed = safeParse(request, (value) => V2KeysWhoamiRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41106,12 +41440,12 @@ var init_keysWhoami = __esm(() => {
 });
 
 // src/mcp-server/tools/keysWhoami.ts
-var args24, tool$keysWhoami;
+var args25, tool$keysWhoami;
 var init_keysWhoami2 = __esm(() => {
   init_keysWhoami();
   init_components();
   init_tools();
-  args24 = {
+  args25 = {
     request: V2KeysWhoamiRequestBody$inboundSchema
   };
   tool$keysWhoami = {
@@ -41128,9 +41462,9 @@ Your root key must have one of the following permissions for basic key informati
 
 If your rootkey lacks permissions but the key exists, we may return a 404 status here to prevent leaking the existance of a key to unauthorized clients. If you believe that a key should exist, but receive a 404, please double check your root key has the correct permissions.
 `,
-    args: args24,
-    tool: async (client, args25, ctx) => {
-      const [result, apiCall] = await keysWhoami(client, args25.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args25,
+    tool: async (client, args26, ctx) => {
+      const [result, apiCall] = await keysWhoami(client, args26.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41145,9 +41479,9 @@ If your rootkey lacks permissions but the key exists, we may return a 404 status
 
 // src/funcs/permissionsCreatePermission.ts
 function permissionsCreatePermission(client, request, options) {
-  return new APIPromise($do25(client, request, options));
+  return new APIPromise($do26(client, request, options));
 }
-async function $do25(client, request, options) {
+async function $do26(client, request, options) {
   const parsed = safeParse(request, (value) => V2PermissionsCreatePermissionRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41227,12 +41561,12 @@ var init_permissionsCreatePermission = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsCreatePermission.ts
-var args25, tool$permissionsCreatePermission;
+var args26, tool$permissionsCreatePermission;
 var init_permissionsCreatePermission2 = __esm(() => {
   init_permissionsCreatePermission();
   init_components();
   init_tools();
-  args25 = {
+  args26 = {
     request: V2PermissionsCreatePermissionRequestBody$inboundSchema
   };
   tool$permissionsCreatePermission = {
@@ -41250,9 +41584,9 @@ Use hierarchical naming patterns like \`documents.read\`, \`admin.users.delete\`
 Your root key must have the following permission:
 - \`rbac.*.create_permission\`
 `,
-    args: args25,
-    tool: async (client, args26, ctx) => {
-      const [result, apiCall] = await permissionsCreatePermission(client, args26.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args26,
+    tool: async (client, args27, ctx) => {
+      const [result, apiCall] = await permissionsCreatePermission(client, args27.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41267,9 +41601,9 @@ Your root key must have the following permission:
 
 // src/funcs/permissionsCreateRole.ts
 function permissionsCreateRole(client, request, options) {
-  return new APIPromise($do26(client, request, options));
+  return new APIPromise($do27(client, request, options));
 }
-async function $do26(client, request, options) {
+async function $do27(client, request, options) {
   const parsed = safeParse(request, (value) => V2PermissionsCreateRoleRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41349,12 +41683,12 @@ var init_permissionsCreateRole = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsCreateRole.ts
-var args26, tool$permissionsCreateRole;
+var args27, tool$permissionsCreateRole;
 var init_permissionsCreateRole2 = __esm(() => {
   init_permissionsCreateRole();
   init_components();
   init_tools();
-  args26 = {
+  args27 = {
     request: V2PermissionsCreateRoleRequestBody$inboundSchema
   };
   tool$permissionsCreateRole = {
@@ -41370,9 +41704,9 @@ Create a new role to group related permissions for easier management. Roles enab
 Your root key must have the following permission:
 - \`rbac.*.create_role\`
 `,
-    args: args26,
-    tool: async (client, args27, ctx) => {
-      const [result, apiCall] = await permissionsCreateRole(client, args27.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args27,
+    tool: async (client, args28, ctx) => {
+      const [result, apiCall] = await permissionsCreateRole(client, args28.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41387,9 +41721,9 @@ Your root key must have the following permission:
 
 // src/funcs/permissionsDeletePermission.ts
 function permissionsDeletePermission(client, request, options) {
-  return new APIPromise($do27(client, request, options));
+  return new APIPromise($do28(client, request, options));
 }
-async function $do27(client, request, options) {
+async function $do28(client, request, options) {
   const parsed = safeParse(request, (value) => V2PermissionsDeletePermissionRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41469,12 +41803,12 @@ var init_permissionsDeletePermission = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsDeletePermission.ts
-var args27, tool$permissionsDeletePermission;
+var args28, tool$permissionsDeletePermission;
 var init_permissionsDeletePermission2 = __esm(() => {
   init_permissionsDeletePermission();
   init_components();
   init_tools();
-  args27 = {
+  args28 = {
     request: V2PermissionsDeletePermissionRequestBody$inboundSchema
   };
   tool$permissionsDeletePermission = {
@@ -41490,9 +41824,9 @@ Remove a permission from your workspace. This also removes the permission from a
 Your root key must have the following permission:
 - \`rbac.*.delete_permission\`
 `,
-    args: args27,
-    tool: async (client, args28, ctx) => {
-      const [result, apiCall] = await permissionsDeletePermission(client, args28.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args28,
+    tool: async (client, args29, ctx) => {
+      const [result, apiCall] = await permissionsDeletePermission(client, args29.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41507,9 +41841,9 @@ Your root key must have the following permission:
 
 // src/funcs/permissionsDeleteRole.ts
 function permissionsDeleteRole(client, request, options) {
-  return new APIPromise($do28(client, request, options));
+  return new APIPromise($do29(client, request, options));
 }
-async function $do28(client, request, options) {
+async function $do29(client, request, options) {
   const parsed = safeParse(request, (value) => V2PermissionsDeleteRoleRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41589,12 +41923,12 @@ var init_permissionsDeleteRole = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsDeleteRole.ts
-var args28, tool$permissionsDeleteRole;
+var args29, tool$permissionsDeleteRole;
 var init_permissionsDeleteRole2 = __esm(() => {
   init_permissionsDeleteRole();
   init_components();
   init_tools();
-  args28 = {
+  args29 = {
     request: V2PermissionsDeleteRoleRequestBody$inboundSchema
   };
   tool$permissionsDeleteRole = {
@@ -41610,9 +41944,9 @@ Remove a role from your workspace. This also removes the role from all assigned
 Your root key must have the following permission:
 - \`rbac.*.delete_role\`
 `,
-    args: args28,
-    tool: async (client, args29, ctx) => {
-      const [result, apiCall] = await permissionsDeleteRole(client, args29.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args29,
+    tool: async (client, args30, ctx) => {
+      const [result, apiCall] = await permissionsDeleteRole(client, args30.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41627,9 +41961,9 @@ Your root key must have the following permission:
 
 // src/funcs/permissionsGetPermission.ts
 function permissionsGetPermission(client, request, options) {
-  return new APIPromise($do29(client, request, options));
+  return new APIPromise($do30(client, request, options));
 }
-async function $do29(client, request, options) {
+async function $do30(client, request, options) {
   const parsed = safeParse(request, (value) => V2PermissionsGetPermissionRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41709,12 +42043,12 @@ var init_permissionsGetPermission = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsGetPermission.ts
-var args29, tool$permissionsGetPermission;
+var args30, tool$permissionsGetPermission;
 var init_permissionsGetPermission2 = __esm(() => {
   init_permissionsGetPermission();
   init_components();
   init_tools();
-  args29 = {
+  args30 = {
     request: V2PermissionsGetPermissionRequestBody$inboundSchema
   };
   tool$permissionsGetPermission = {
@@ -41728,9 +42062,9 @@ Retrieve details about a specific permission including its name, description, an
 Your root key must have the following permission:
 - \`rbac.*.read_permission\`
 `,
-    args: args29,
-    tool: async (client, args30, ctx) => {
-      const [result, apiCall] = await permissionsGetPermission(client, args30.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args30,
+    tool: async (client, args31, ctx) => {
+      const [result, apiCall] = await permissionsGetPermission(client, args31.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41745,9 +42079,9 @@ Your root key must have the following permission:
 
 // src/funcs/permissionsGetRole.ts
 function permissionsGetRole(client, request, options) {
-  return new APIPromise($do30(client, request, options));
+  return new APIPromise($do31(client, request, options));
 }
-async function $do30(client, request, options) {
+async function $do31(client, request, options) {
   const parsed = safeParse(request, (value) => V2PermissionsGetRoleRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41827,12 +42161,12 @@ var init_permissionsGetRole = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsGetRole.ts
-var args30, tool$permissionsGetRole;
+var args31, tool$permissionsGetRole;
 var init_permissionsGetRole2 = __esm(() => {
   init_permissionsGetRole();
   init_components();
   init_tools();
-  args30 = {
+  args31 = {
     request: V2PermissionsGetRoleRequestBody$inboundSchema
   };
   tool$permissionsGetRole = {
@@ -41846,9 +42180,9 @@ Retrieve details about a specific role including its assigned permissions.
 Your root key must have the following permission:
 - \`rbac.*.read_role\`
 `,
-    args: args30,
-    tool: async (client, args31, ctx) => {
-      const [result, apiCall] = await permissionsGetRole(client, args31.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args31,
+    tool: async (client, args32, ctx) => {
+      const [result, apiCall] = await permissionsGetRole(client, args32.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41863,9 +42197,9 @@ Your root key must have the following permission:
 
 // src/funcs/permissionsListPermissions.ts
 function permissionsListPermissions(client, request, options) {
-  return new APIPromise($do31(client, request, options));
+  return new APIPromise($do32(client, request, options));
 }
-async function $do31(client, request, options) {
+async function $do32(client, request, options) {
   const parsed = safeParse(request, (value) => V2PermissionsListPermissionsRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41945,12 +42279,12 @@ var init_permissionsListPermissions = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsListPermissions.ts
-var args31, tool$permissionsListPermissions;
+var args32, tool$permissionsListPermissions;
 var init_permissionsListPermissions2 = __esm(() => {
   init_permissionsListPermissions();
   init_components();
   init_tools();
-  args31 = {
+  args32 = {
     request: V2PermissionsListPermissionsRequestBody$inboundSchema
   };
   tool$permissionsListPermissions = {
@@ -41965,9 +42299,9 @@ Results are paginated and sorted by their id.
 Your root key must have the following permission:
 - \`rbac.*.read_permission\`
 `,
-    args: args31,
-    tool: async (client, args32, ctx) => {
-      const [result, apiCall] = await permissionsListPermissions(client, args32.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args32,
+    tool: async (client, args33, ctx) => {
+      const [result, apiCall] = await permissionsListPermissions(client, args33.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41982,9 +42316,9 @@ Your root key must have the following permission:
 
 // src/funcs/permissionsListRoles.ts
 function permissionsListRoles(client, request, options) {
-  return new APIPromise($do32(client, request, options));
+  return new APIPromise($do33(client, request, options));
 }
-async function $do32(client, request, options) {
+async function $do33(client, request, options) {
   const parsed = safeParse(request, (value) => V2PermissionsListRolesRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42064,12 +42398,12 @@ var init_permissionsListRoles = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsListRoles.ts
-var args32, tool$permissionsListRoles;
+var args33, tool$permissionsListRoles;
 var init_permissionsListRoles2 = __esm(() => {
   init_permissionsListRoles();
   init_components();
   init_tools();
-  args32 = {
+  args33 = {
     request: V2PermissionsListRolesRequestBody$inboundSchema
   };
   tool$permissionsListRoles = {
@@ -42084,9 +42418,9 @@ Results are paginated and sorted by their id.
 Your root key must have the following permission:
 - \`rbac.*.read_role\`
 `,
-    args: args32,
-    tool: async (client, args33, ctx) => {
-      const [result, apiCall] = await permissionsListRoles(client, args33.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args33,
+    tool: async (client, args34, ctx) => {
+      const [result, apiCall] = await permissionsListRoles(client, args34.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42101,9 +42435,9 @@ Your root key must have the following permission:
 
 // src/funcs/ratelimitDeleteOverride.ts
 function ratelimitDeleteOverride(client, request, options) {
-  return new APIPromise($do33(client, request, options));
+  return new APIPromise($do34(client, request, options));
 }
-async function $do33(client, request, options) {
+async function $do34(client, request, options) {
   const parsed = safeParse(request, (value) => V2RatelimitDeleteOverrideRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42183,12 +42517,12 @@ var init_ratelimitDeleteOverride = __esm(() => {
 });
 
 // src/mcp-server/tools/ratelimitDeleteOverride.ts
-var args33, tool$ratelimitDeleteOverride;
+var args34, tool$ratelimitDeleteOverride;
 var init_ratelimitDeleteOverride2 = __esm(() => {
   init_ratelimitDeleteOverride();
   init_components();
   init_tools();
-  args33 = {
+  args34 = {
     request: V2RatelimitDeleteOverrideRequestBody$inboundSchema
   };
   tool$ratelimitDeleteOverride = {
@@ -42203,9 +42537,9 @@ Use this to remove temporary overrides, reset identifiers to standard limits, or
 
 **Permissions:** Requires \`ratelimit.*.delete_override\` or \`ratelimit.<namespace_id>.delete_override\`
 `,
-    args: args33,
-    tool: async (client, args34, ctx) => {
-      const [result, apiCall] = await ratelimitDeleteOverride(client, args34.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args34,
+    tool: async (client, args35, ctx) => {
+      const [result, apiCall] = await ratelimitDeleteOverride(client, args35.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42220,9 +42554,9 @@ Use this to remove temporary overrides, reset identifiers to standard limits, or
 
 // src/funcs/ratelimitGetOverride.ts
 function ratelimitGetOverride(client, request, options) {
-  return new APIPromise($do34(client, request, options));
+  return new APIPromise($do35(client, request, options));
 }
-async function $do34(client, request, options) {
+async function $do35(client, request, options) {
   const parsed = safeParse(request, (value) => V2RatelimitGetOverrideRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42302,12 +42636,12 @@ var init_ratelimitGetOverride = __esm(() => {
 });
 
 // src/mcp-server/tools/ratelimitGetOverride.ts
-var args34, tool$ratelimitGetOverride;
+var args35, tool$ratelimitGetOverride;
 var init_ratelimitGetOverride2 = __esm(() => {
   init_ratelimitGetOverride();
   init_components();
   init_tools();
-  args34 = {
+  args35 = {
     request: V2RatelimitGetOverrideRequestBody$inboundSchema
   };
   tool$ratelimitGetOverride = {
@@ -42322,9 +42656,9 @@ Use this to inspect override configurations, audit rate limiting policies, or de
 
 **Permissions:** Requires \`ratelimit.*.read_override\` or \`ratelimit.<namespace_id>.read_override\`
 `,
-    args: args34,
-    tool: async (client, args35, ctx) => {
-      const [result, apiCall] = await ratelimitGetOverride(client, args35.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args35,
+    tool: async (client, args36, ctx) => {
+      const [result, apiCall] = await ratelimitGetOverride(client, args36.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42339,9 +42673,9 @@ Use this to inspect override configurations, audit rate limiting policies, or de
 
 // src/funcs/ratelimitLimit.ts
 function ratelimitLimit(client, request, options) {
-  return new APIPromise($do35(client, request, options));
+  return new APIPromise($do36(client, request, options));
 }
-async function $do35(client, request, options) {
+async function $do36(client, request, options) {
   const parsed = safeParse(request, (value) => V2RatelimitLimitRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42421,12 +42755,12 @@ var init_ratelimitLimit = __esm(() => {
 });
 
 // src/mcp-server/tools/ratelimitLimit.ts
-var args35, tool$ratelimitLimit;
+var args36, tool$ratelimitLimit;
 var init_ratelimitLimit2 = __esm(() => {
   init_ratelimitLimit();
   init_components();
   init_tools();
-  args35 = {
+  args36 = {
     request: V2RatelimitLimitRequestBody$inboundSchema
   };
   tool$ratelimitLimit = {
@@ -42444,14 +42778,10 @@ Use this for rate limiting beyond API keys - limit users by ID, IPs by address,
 Your root key must have one of the following permissions:
 - \`ratelimit.*.limit\` (to check limits in any namespace)
 - \`ratelimit.<namespace_id>.limit\` (to check limits in a specific namespace)
-
-**Side Effects**
-
-Records rate limit metrics for analytics and monitoring, updates rate limit counters with sliding window algorithm, and optionally triggers override matching for custom limits.
 `,
-    args: args35,
-    tool: async (client, args36, ctx) => {
-      const [result, apiCall] = await ratelimitLimit(client, args36.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args36,
+    tool: async (client, args37, ctx) => {
+      const [result, apiCall] = await ratelimitLimit(client, args37.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42466,9 +42796,9 @@ Records rate limit metrics for analytics and monitoring, updates rate limit coun
 
 // src/funcs/ratelimitListOverrides.ts
 function ratelimitListOverrides(client, request, options) {
-  return new APIPromise($do36(client, request, options));
+  return new APIPromise($do37(client, request, options));
 }
-async function $do36(client, request, options) {
+async function $do37(client, request, options) {
   const parsed = safeParse(request, (value) => V2RatelimitListOverridesRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42548,12 +42878,12 @@ var init_ratelimitListOverrides = __esm(() => {
 });
 
 // src/mcp-server/tools/ratelimitListOverrides.ts
-var args36, tool$ratelimitListOverrides;
+var args37, tool$ratelimitListOverrides;
 var init_ratelimitListOverrides2 = __esm(() => {
   init_ratelimitListOverrides();
   init_components();
   init_tools();
-  args36 = {
+  args37 = {
     request: V2RatelimitListOverridesRequestBody$inboundSchema
   };
   tool$ratelimitListOverrides = {
@@ -42568,9 +42898,134 @@ Use this to audit rate limiting policies, build admin dashboards, or manage over
 
 **Permissions:** Requires \`ratelimit.*.read_override\` or \`ratelimit.<namespace_id>.read_override\`
 `,
-    args: args36,
-    tool: async (client, args37, ctx) => {
-      const [result, apiCall] = await ratelimitListOverrides(client, args37.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args37,
+    tool: async (client, args38, ctx) => {
+      const [result, apiCall] = await ratelimitListOverrides(client, args38.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/ratelimitMultiLimit.ts
+function ratelimitMultiLimit(client, request, options) {
+  return new APIPromise($do38(client, request, options));
+}
+async function $do38(client, request, options) {
+  const parsed = safeParse(request, (value) => arrayType(V2RatelimitLimitRequestBody$outboundSchema).parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/v2/ratelimit.multiLimit")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.rootKey);
+  const securityInput = secConfig == null ? {} : { rootKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "ratelimit.multiLimit",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.rootKey,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 50,
+        maxInterval: 1000,
+        exponent: 1.5,
+        maxElapsedTime: 1e4
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    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", "401", "403", "404", "410", "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, V2RatelimitMultiLimitResponseBody$inboundSchema), jsonErr(400, BadRequestErrorResponse$inboundSchema), jsonErr(401, UnauthorizedErrorResponse$inboundSchema), jsonErr(403, ForbiddenErrorResponse$inboundSchema), jsonErr(404, NotFoundErrorResponse$inboundSchema), jsonErr(410, GoneErrorResponse$inboundSchema), jsonErr(500, InternalServerErrorResponse$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_ratelimitMultiLimit = __esm(() => {
+  init_v3();
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_async();
+});
+
+// src/mcp-server/tools/ratelimitMultiLimit.ts
+var args38, tool$ratelimitMultiLimit;
+var init_ratelimitMultiLimit2 = __esm(() => {
+  init_v3();
+  init_ratelimitMultiLimit();
+  init_components();
+  init_tools();
+  args38 = {
+    request: arrayType(V2RatelimitLimitRequestBody$inboundSchema)
+  };
+  tool$ratelimitMultiLimit = {
+    name: "ratelimit-multi-limit",
+    description: `Apply multiple rate limit checks
+
+Check and enforce multiple rate limits in a single request for any identifiers (user IDs, IP addresses, API clients, etc.).
+
+Use this to efficiently check multiple rate limits at once. Each rate limit check is independent and returns its own result with a top-level \`passed\` indicator showing if all checks succeeded.
+
+**Response Codes**: Rate limit checks return HTTP 200 regardless of whether limits are exceeded - check the \`passed\` field to see if all limits passed, or the \`success\` field in each individual result. 4xx responses indicate auth, namespace existence/deletion, or validation errors (e.g., 410 Gone for deleted namespaces). 5xx responses indicate server errors.
+
+**Required Permissions**
+
+Your root key must have one of the following permissions:
+- \`ratelimit.*.limit\` (to check limits in any namespace)
+- \`ratelimit.<namespace_id>.limit\` (to check limits in all specific namespaces being checked)
+`,
+    args: args38,
+    tool: async (client, args39, ctx) => {
+      const [result, apiCall] = await ratelimitMultiLimit(client, args39.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42585,9 +43040,9 @@ Use this to audit rate limiting policies, build admin dashboards, or manage over
 
 // src/funcs/ratelimitSetOverride.ts
 function ratelimitSetOverride(client, request, options) {
-  return new APIPromise($do37(client, request, options));
+  return new APIPromise($do39(client, request, options));
 }
-async function $do37(client, request, options) {
+async function $do39(client, request, options) {
   const parsed = safeParse(request, (value) => V2RatelimitSetOverrideRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42667,12 +43122,12 @@ var init_ratelimitSetOverride = __esm(() => {
 });
 
 // src/mcp-server/tools/ratelimitSetOverride.ts
-var args37, tool$ratelimitSetOverride;
+var args39, tool$ratelimitSetOverride;
 var init_ratelimitSetOverride2 = __esm(() => {
   init_ratelimitSetOverride();
   init_components();
   init_tools();
-  args37 = {
+  args39 = {
     request: V2RatelimitSetOverrideRequestBody$inboundSchema
   };
   tool$ratelimitSetOverride = {
@@ -42687,9 +43142,9 @@ Use this to create premium tiers with higher limits, apply stricter limits to sp
 
 **Permissions:** Requires \`ratelimit.*.set_override\` or \`ratelimit.<namespace_id>.set_override\`
 `,
-    args: args37,
-    tool: async (client, args38, ctx) => {
-      const [result, apiCall] = await ratelimitSetOverride(client, args38.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args39,
+    tool: async (client, args40, ctx) => {
+      const [result, apiCall] = await ratelimitSetOverride(client, args40.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42706,7 +43161,7 @@ Use this to create premium tiers with higher limits, apply stricter limits to sp
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "Unkey",
-    version: "2.1.0"
+    version: "2.1.2"
   });
   const client = new UnkeyCore({
     rootKey: deps.rootKey,
@@ -42735,6 +43190,7 @@ function createMCPServer(deps) {
   tool(tool$keysCreateKey);
   tool(tool$keysDeleteKey);
   tool(tool$keysGetKey);
+  tool(tool$keysMigrateKeys);
   tool(tool$keysRemovePermissions);
   tool(tool$keysRemoveRoles);
   tool(tool$keysRerollKey);
@@ -42756,6 +43212,7 @@ function createMCPServer(deps) {
   tool(tool$ratelimitGetOverride);
   tool(tool$ratelimitLimit);
   tool(tool$ratelimitListOverrides);
+  tool(tool$ratelimitMultiLimit);
   tool(tool$ratelimitSetOverride);
   return server;
 }
@@ -42779,6 +43236,7 @@ var init_server2 = __esm(() => {
   init_keysCreateKey2();
   init_keysDeleteKey2();
   init_keysGetKey2();
+  init_keysMigrateKeys2();
   init_keysRemovePermissions2();
   init_keysRemoveRoles2();
   init_keysRerollKey2();
@@ -42800,6 +43258,7 @@ var init_server2 = __esm(() => {
   init_ratelimitGetOverride2();
   init_ratelimitLimit2();
   init_ratelimitListOverrides2();
+  init_ratelimitMultiLimit2();
   init_ratelimitSetOverride2();
 });
 
@@ -43996,7 +44455,7 @@ var routes = ln({
 var app = _e(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "2.1.0"
+    currentVersion: "2.1.2"
   }
 });
 Yt(app, process3.argv.slice(2), buildContext(process3));
@@ -44004,5 +44463,5 @@ export {
   app
 };
 
-//# debugId=2814142040324B2664756E2164756E21
+//# debugId=77A6B0E086C5EA3664756E2164756E21
 //# sourceMappingURL=mcp-server.js.map