@kaminari-ad/mcp 0.2.2 → 0.3.0

package/dist/{chunk-4MNLSWSZ.js → chunk-W7TPFRJB.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { err, ok } from './chunk-BAZQPU6T.js';
+import { err, ok } from './chunk-KTQBHJUB.js';
 import { createHash, randomUUID } from 'crypto';
 import createClient from 'openapi-fetch';
 import { fetch } from 'undici';
@@ -148,12 +148,20 @@ function toApiError(status2, parsed, retryAfterHeader) {
   }
   return { kind: "upstream", detail: message, status: status2 };
 }
+var OrganizationStatus = z.enum([
+  "pending_email_verification",
+  "pending_admin_approval",
+  "active",
+  "suspended",
+  "rejected"
+]);
 var OrgResponse = z.object({
   id: z.string().uuid(),
   name: z.string(),
   owner_id: z.string().uuid(),
-  is_active: z.boolean(),
-  created_at: z.string().datetime({ offset: true })
+  status: OrganizationStatus,
+  created_at: z.string().datetime({ offset: true }),
+  is_active: z.boolean()
 }).passthrough();
 z.object({ name: z.union([z.string(), z.null()]) }).partial().passthrough();
 var ValidationError = z.object({
@@ -164,7 +172,7 @@ var ValidationError = z.object({
   ctx: z.object({}).partial().passthrough().optional()
 }).passthrough();
 z.object({ detail: z.array(ValidationError) }).partial().passthrough();
-z.object({
+var LabelDefinitionResponse = z.object({
   key: z.string(),
   display_name: z.string(),
   position: z.number().int(),
@@ -180,7 +188,10 @@ var UserResponse = z.object({
   id: z.string().uuid(),
   email: z.string(),
   name: z.string(),
+  role_id: z.string().uuid(),
   role_name: z.string(),
+  organization_id: z.string().uuid(),
+  organization_name: z.string(),
   is_active: z.boolean(),
   created_at: z.string().datetime({ offset: true })
 }).passthrough();
@@ -271,16 +282,35 @@ var ProxyTargetResponse = z.object({
   city: z.string().optional().default(""),
   isp: z.string().optional().default("")
 }).passthrough();
-var IabCategoryResponse = z.object({
+var AiCategoryResponse = z.object({
   tier1: z.string(),
   tier2: z.union([z.string(), z.null()]).optional(),
   tier3: z.union([z.string(), z.null()]).optional(),
   tier4: z.union([z.string(), z.null()]).optional()
 }).passthrough();
+var IabV3CategoryResponse = z.object({
+  tier1: z.string(),
+  tier2: z.union([z.string(), z.null()]).optional(),
+  tier3: z.union([z.string(), z.null()]).optional(),
+  tier4: z.union([z.string(), z.null()]).optional()
+}).passthrough();
+var ScanTaxonomyClassificationResponse = z.object({
+  taxonomy_id: z.string().uuid(),
+  taxonomy_name: z.string(),
+  taxonomy_slug: z.string(),
+  taxonomy_version: z.number().int(),
+  leaf_node_id: z.union([z.string(), z.null()]),
+  tier1: z.union([z.string(), z.null()]),
+  tier2: z.union([z.string(), z.null()]).optional(),
+  tier3: z.union([z.string(), z.null()]).optional(),
+  tier4: z.union([z.string(), z.null()]).optional(),
+  used_default: z.boolean().optional().default(false)
+}).passthrough();
 var ScanClassificationResponse = z.object({
   brand: z.union([z.string(), z.null()]),
-  iab_v2: z.union([IabCategoryResponse, z.null()]),
-  iab_v3: z.union([IabCategoryResponse, z.null()])
+  ai_category: z.union([AiCategoryResponse, z.null()]),
+  iab_v3: z.union([IabV3CategoryResponse, z.null()]),
+  custom_taxonomies: z.array(ScanTaxonomyClassificationResponse).default([])
 }).partial().passthrough();
 var LandingResponse = z.object({
   ord: z.number().int(),
@@ -532,7 +562,7 @@ var TagDefinitionWithStatsResponse = z.object({
   description: z.string(),
   is_system: z.boolean(),
   organization_id: z.union([z.string(), z.null()]),
-  show_in_public_report: z.boolean(),
+  visibility: z.string(),
   severity: z.string(),
   scans_count: z.number().int(),
   rules_count: z.number().int()
@@ -552,17 +582,18 @@ var TagDefinitionDetailResponse = z.object({
   description: z.string(),
   is_system: z.boolean(),
   organization_id: z.union([z.string(), z.null()]),
-  show_in_public_report: z.boolean(),
+  visibility: z.string(),
   severity: z.string(),
   scans_count: z.number().int(),
   rules_count: z.number().int(),
   linked_rules: z.array(LinkedRuleResponse).optional()
 }).passthrough();
+var TagVisibility = z.enum(["hidden", "internal", "public"]);
 var TagSeverity = z.enum(["high", "medium", "low"]);
 z.object({
   display_name: z.union([z.string(), z.null()]),
   description: z.union([z.string(), z.null()]),
-  show_in_public_report: z.union([z.boolean(), z.null()]),
+  visibility: z.union([TagVisibility, z.null()]),
   severity: z.union([TagSeverity, z.null()])
 }).partial().passthrough();
 z.object({
@@ -613,18 +644,66 @@ var RuleTestResponse = z.object({
   llm_prompt_url: z.string().optional().default(""),
   llm_response_url: z.string().optional().default("")
 }).passthrough();
-var PolicyEntryRequest = z.object({
-  tag_slug: z.string().min(1).max(100),
-  country_codes: z.array(z.string()).max(50).optional()
+var IabV3PolicyCategoryRequest = z.object({
+  tier1: z.string().min(1).max(200),
+  tier2: z.union([z.string(), z.null()]).optional(),
+  tier3: z.union([z.string(), z.null()]).optional(),
+  tier4: z.union([z.string(), z.null()]).optional()
+}).passthrough();
+var AiCategoryRequest = z.object({
+  tier1: z.string().min(1).max(200),
+  tier2: z.union([z.string(), z.null()]).optional(),
+  tier3: z.union([z.string(), z.null()]).optional(),
+  tier4: z.union([z.string(), z.null()]).optional()
+}).passthrough();
+var CustomTaxonomyRefRequest = z.object({
+  taxonomy_id: z.string().uuid(),
+  tier1: z.string().min(1).max(200),
+  tier2: z.union([z.string(), z.null()]).optional(),
+  tier3: z.union([z.string(), z.null()]).optional(),
+  tier4: z.union([z.string(), z.null()]).optional()
 }).passthrough();
+var PolicyEntryRequest = z.object({
+  rule_type: z.enum(["tag", "iab_v3", "brand", "ai_category", "custom_taxonomy"]).default("tag"),
+  tag_slug: z.union([z.string(), z.null()]),
+  iab_v3: z.union([IabV3PolicyCategoryRequest, z.null()]),
+  brand: z.union([z.string(), z.null()]),
+  ai_category: z.union([AiCategoryRequest, z.null()]),
+  custom_taxonomy: z.union([CustomTaxonomyRefRequest, z.null()]),
+  country_codes: z.array(z.string()).max(50)
+}).partial().passthrough();
 z.object({
   name: z.string().min(1).max(200),
   description: z.string().max(2e3).optional().default(""),
   entries: z.array(PolicyEntryRequest).min(1).max(500)
 }).passthrough();
+var PolicyEntryIabV3Response = z.object({
+  tier1: z.string(),
+  tier2: z.union([z.string(), z.null()]).optional(),
+  tier3: z.union([z.string(), z.null()]).optional(),
+  tier4: z.union([z.string(), z.null()]).optional()
+}).passthrough();
+var PolicyEntryAiCategoryResponse = z.object({
+  tier1: z.string(),
+  tier2: z.union([z.string(), z.null()]).optional(),
+  tier3: z.union([z.string(), z.null()]).optional(),
+  tier4: z.union([z.string(), z.null()]).optional()
+}).passthrough();
+var PolicyEntryCustomTaxonomyResponse = z.object({
+  taxonomy_id: z.string().uuid(),
+  tier1: z.string(),
+  tier2: z.union([z.string(), z.null()]).optional(),
+  tier3: z.union([z.string(), z.null()]).optional(),
+  tier4: z.union([z.string(), z.null()]).optional()
+}).passthrough();
 var PolicyEntryResponse = z.object({
   id: z.string().uuid(),
-  tag_slug: z.string(),
+  rule_type: z.string(),
+  tag_slug: z.union([z.string(), z.null()]).optional(),
+  iab_v3: z.union([PolicyEntryIabV3Response, z.null()]).optional(),
+  brand: z.union([z.string(), z.null()]).optional(),
+  ai_category: z.union([PolicyEntryAiCategoryResponse, z.null()]).optional(),
+  custom_taxonomy: z.union([PolicyEntryCustomTaxonomyResponse, z.null()]).optional(),
   country_codes: z.array(z.string())
 }).passthrough();
 var PolicySetResponse = z.object({
@@ -677,7 +756,9 @@ var AlertResponse = z.object({
   updated_at: z.union([z.string(), z.null()]),
   scan_url: z.string(),
   offer_url: z.string(),
-  tag_display_name: z.string()
+  tag_display_name: z.string(),
+  rule_type: z.string().optional().default("tag"),
+  matched_value: z.union([z.string(), z.null()]).optional()
 }).passthrough();
 z.object({
   items: z.array(AlertResponse),
@@ -932,8 +1013,67 @@ z.object({
   id: z.string().uuid(),
   received_at: z.string().datetime({ offset: true })
 }).passthrough();
+var CustomTaxonomyListItem = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.string(),
+  is_active: z.boolean(),
+  version: z.number().int(),
+  node_count: z.number().int(),
+  created_at: z.string().datetime({ offset: true }),
+  updated_at: z.string().datetime({ offset: true })
+}).passthrough();
+var TaxonomyNodeRequest = z.object({
+  client_id: z.string().min(1).max(100),
+  parent_client_id: z.union([z.string(), z.null()]).optional(),
+  name: z.string().min(1).max(100),
+  description: z.string().max(200).optional().default(""),
+  is_default: z.boolean().optional().default(false)
+});
+z.object({
+  name: z.string().min(1).max(100),
+  description: z.string().max(500).optional().default(""),
+  nodes: z.array(TaxonomyNodeRequest).optional().default([])
+});
+var TaxonomyNodeResponse = z.object({
+  id: z.string().uuid(),
+  parent_id: z.union([z.string(), z.null()]),
+  level: z.number().int(),
+  position: z.number().int(),
+  name: z.string(),
+  description: z.string(),
+  is_default: z.boolean()
+}).passthrough();
+var CustomTaxonomyResponse = z.object({
+  id: z.string().uuid(),
+  organization_id: z.string().uuid(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.string(),
+  is_active: z.boolean(),
+  version: z.number().int(),
+  nodes: z.array(TaxonomyNodeResponse),
+  created_at: z.string().datetime({ offset: true }),
+  updated_at: z.string().datetime({ offset: true })
+}).passthrough();
+z.object({
+  text: z.string().min(1).max(5e4)
+});
+var ParsedTaxonomyNode = z.object({
+  level: z.number().int(),
+  name: z.string(),
+  description: z.string()
+}).passthrough();
+var ParseTaxonomyTextResponse = z.object({ nodes: z.array(ParsedTaxonomyNode), warnings: z.array(z.string()) }).passthrough();
+z.object({
+  name: z.string().min(1).max(100),
+  description: z.string().max(500).optional().default(""),
+  nodes: z.array(TaxonomyNodeRequest).optional().default([])
+});
 var schemas = {
   OrgResponse,
+  LabelDefinitionResponse,
   UserResponse,
   ApiKeyResponse,
   ApiKeyCreatedResponse,
@@ -970,7 +1110,12 @@ var schemas = {
   BulkReplayResponse,
   AlertNotificationDestinationResponse,
   CampaignOverridesResponse,
-  InvoiceResponse};
+  InvoiceResponse,
+  CustomTaxonomyListItem,
+  TaxonomyNodeResponse,
+  CustomTaxonomyResponse,
+  ParsedTaxonomyNode,
+  ParseTaxonomyTextResponse};
 function parseWithSchema(schema, raw, label) {
   const parsed = schema.safeParse(raw);
   if (parsed.success) return ok(stripUndefinedKeys(parsed.data));
@@ -1020,6 +1165,8 @@ var AlertSchema = schemas.AlertResponse.pick({
   campaign_id: true,
   policy_set_id: true,
   violation_rule_id: true,
+  rule_type: true,
+  matched_value: true,
   tag_slug: true,
   tag_display_name: true,
   country_code: true,
@@ -1143,6 +1290,49 @@ var CustomRuleSchema2 = schemas.CustomRuleResponse.pick({
   created_at: true
 }).strip();
 var parseCustomRulePage = (raw) => parsePagedWithItemSchema(CustomRuleSchema2, raw, "custom-rules");
+var CustomTaxonomyListItemSchema = schemas.CustomTaxonomyListItem.pick({
+  id: true,
+  name: true,
+  slug: true,
+  description: true,
+  is_active: true,
+  version: true,
+  node_count: true,
+  created_at: true,
+  updated_at: true
+}).strip();
+var CustomTaxonomyListSchema = z.array(CustomTaxonomyListItemSchema);
+var TaxonomyNodeSchema = schemas.TaxonomyNodeResponse.pick({
+  id: true,
+  parent_id: true,
+  level: true,
+  position: true,
+  name: true,
+  description: true,
+  is_default: true
+}).strip();
+var CustomTaxonomySchema = schemas.CustomTaxonomyResponse.pick({
+  id: true,
+  organization_id: true,
+  name: true,
+  slug: true,
+  description: true,
+  is_active: true,
+  version: true,
+  created_at: true,
+  updated_at: true
+}).extend({ nodes: z.array(TaxonomyNodeSchema) }).strip();
+var ParsedTaxonomyNodeSchema = schemas.ParsedTaxonomyNode.pick({
+  level: true,
+  name: true,
+  description: true
+}).strip();
+var ParseTaxonomyTextResponseSchema = schemas.ParseTaxonomyTextResponse.pick({
+  warnings: true
+}).extend({ nodes: z.array(ParsedTaxonomyNodeSchema) }).strip();
+var parseCustomTaxonomyList = (raw) => parseWithSchema(CustomTaxonomyListSchema, raw, "custom-taxonomies");
+var parseCustomTaxonomy = (raw) => parseWithSchema(CustomTaxonomySchema, raw, "custom-taxonomy");
+var parseTaxonomyTextPreview = (raw) => parseWithSchema(ParseTaxonomyTextResponseSchema, raw, "custom-taxonomy-parse-text");
 
 // src/infrastructure/api/parsers/parse-empty.ts
 function parseEmpty(_raw) {
@@ -1213,6 +1403,13 @@ var RoleSchema = schemas.RoleResponse.pick({
   permissions: true
 }).strip();
 var parseRole = (raw) => parseWithSchema(RoleSchema, raw, "role");
+var LabelDefinitionSchema = schemas.LabelDefinitionResponse.pick({
+  key: true,
+  display_name: true,
+  position: true,
+  auto_extract: true
+}).strip();
+var parseLabelDefinition = (raw) => parseWithSchema(LabelDefinitionSchema, raw, "label-definition");
 var ApiKeyCreatedSchema = schemas.ApiKeyCreatedResponse.pick({
   id: true,
   key_prefix: true,
@@ -1354,7 +1551,12 @@ var GroupActionSchema = schemas.GroupActionResponse.pick({
 var parseGroupAction = (raw) => parseWithSchema(GroupActionSchema, raw, "group-action");
 schemas.PolicyEntryResponse.pick({
   id: true,
+  rule_type: true,
   tag_slug: true,
+  iab_v3: true,
+  brand: true,
+  ai_category: true,
+  custom_taxonomy: true,
   country_codes: true
 }).strip();
 var GeoSchema = schemas.GeoResponse.pick({
@@ -1465,7 +1667,7 @@ var TagDefinitionSchema = schemas.TagDefinitionWithStatsResponse.pick({
   severity: true,
   is_system: true,
   organization_id: true,
-  show_in_public_report: true,
+  visibility: true,
   scans_count: true,
   rules_count: true
 }).strip();
@@ -1484,7 +1686,7 @@ var TagDetailSchema = schemas.TagDefinitionDetailResponse.pick({
   severity: true,
   is_system: true,
   organization_id: true,
-  show_in_public_report: true,
+  visibility: true,
   scans_count: true,
   rules_count: true
 }).extend({ linked_rules: z.array(LinkedRuleSchema).optional() }).strip();
@@ -1592,6 +1794,56 @@ function createHttpApiGateway(config) {
     }
     return err(toApiError(status2, error ?? data, response.headers.get("retry-after") ?? void 0));
   }
+  async function binaryGet(path, query) {
+    const startedAtMs = Date.now();
+    const qs = query && Object.keys(query).length > 0 ? `?${new URLSearchParams(
+      Object.fromEntries(Object.entries(query).map(([k, v]) => [k, String(v)]))
+    ).toString()}` : "";
+    const url = `${baseUrl}${path}${qs}`;
+    let response;
+    try {
+      const init = {
+        method: "GET",
+        // Header allowlist: see binaryGet docstring above. Keep this
+        // map minimal; any future addition needs a CONTRIBUTING.md
+        // update + a tenant-isolation review.
+        headers: {
+          authorization: bearer.toAuthorizationHeader(),
+          accept: "image/*, application/pdf, application/octet-stream",
+          "user-agent": "kaminari-ad-mcp",
+          "x-request-id": requestId
+        }
+      };
+      if (dispatcher !== void 0) init["dispatcher"] = dispatcher;
+      response = await fetch(
+        url,
+        init
+      );
+    } catch (cause) {
+      logger.warn({ api_path: path, elapsed_ms: Date.now() - startedAtMs }, "api.network_error");
+      const inner = cause instanceof Error && cause.cause instanceof Error ? cause.cause : cause instanceof Error ? cause : null;
+      return err({ kind: "upstream", detail: inner !== null ? inner.message : "network error" });
+    }
+    const status2 = response.status;
+    logger.info(
+      { api_path: path, api_status: status2, elapsed_ms: Date.now() - startedAtMs },
+      "api.done"
+    );
+    if (status2 >= 200 && status2 < 300) {
+      const buf = await response.arrayBuffer();
+      return ok({
+        bytes: new Uint8Array(buf),
+        contentType: response.headers.get("content-type") ?? "application/octet-stream"
+      });
+    }
+    let errBody;
+    try {
+      errBody = await response.json();
+    } catch {
+      errBody = void 0;
+    }
+    return err(toApiError(status2, errBody, response.headers.get("retry-after") ?? void 0));
+  }
   return {
     // ── Account ───────────────────────────────────────────────────
     async getAccount() {
@@ -1633,6 +1885,33 @@ function createHttpApiGateway(config) {
     async listOrgRoles() {
       return call("GET", "/api/v1/account/roles", {}, parseArrayOf(parseRole));
     },
+    async createCustomRole(body) {
+      return call("POST", "/api/v1/account/roles", { body }, parseRole);
+    },
+    async listAccountLabels() {
+      return call("GET", "/api/v1/account/labels", {}, parseArrayOf(parseLabelDefinition));
+    },
+    async updateAccountLabels(body) {
+      return call("PUT", "/api/v1/account/labels", { body }, parseArrayOf(parseLabelDefinition));
+    },
+    async getScanScreenshot(scanId, w2) {
+      return binaryGet(`/api/v1/scans/${scanId}/screenshot`, w2 !== void 0 ? { w: w2 } : void 0);
+    },
+    async getScanCreativeScreenshot(scanId, w2) {
+      return binaryGet(
+        `/api/v1/scans/${scanId}/creative-screenshot`,
+        w2 !== void 0 ? { w: w2 } : void 0
+      );
+    },
+    async getScanLandingScreenshot(scanId, landingOrd, w2) {
+      return binaryGet(
+        `/api/v1/scans/${scanId}/landings/${String(landingOrd)}/screenshot`,
+        w2 !== void 0 ? { w: w2 } : void 0
+      );
+    },
+    async getInvoicePdf(invoiceId) {
+      return binaryGet(`/api/v1/invoices/${invoiceId}/pdf`);
+    },
     async listApiKeys() {
       return call("GET", "/api/v1/account/api-keys", {}, parseApiKeyList);
     },
@@ -1759,8 +2038,13 @@ function createHttpApiGateway(config) {
         parsePageOf(parseRun)
       );
     },
-    async listCampaignsPicker() {
-      return call("GET", "/api/v1/campaigns/picker", {}, parseCampaignPickerArray);
+    async listCampaignsPicker(filters) {
+      return call(
+        "GET",
+        "/api/v1/campaigns/picker",
+        filters ? { params: { query: filters } } : {},
+        parseCampaignPickerArray
+      );
     },
     // ── Runs ──────────────────────────────────────────────────────
     async getRun(id) {
@@ -1859,8 +2143,13 @@ function createHttpApiGateway(config) {
       );
     },
     // ── Tag definitions ───────────────────────────────────────────
-    async listTags() {
-      return call("GET", "/api/v1/tag-definitions", {}, parseTagDefinitionArray);
+    async listTags(filters) {
+      return call(
+        "GET",
+        "/api/v1/tag-definitions",
+        filters ? { params: { query: filters } } : {},
+        parseTagDefinitionArray
+      );
     },
     async getTagDefinition(slug) {
       return call(
@@ -1964,6 +2253,53 @@ function createHttpApiGateway(config) {
         parseEmpty
       );
     },
+    // ── Custom taxonomies ─────────────────────────────────────────
+    async listCustomTaxonomies() {
+      return call("GET", "/api/v1/custom-taxonomies", {}, parseCustomTaxonomyList);
+    },
+    async getCustomTaxonomy(id) {
+      return call(
+        "GET",
+        "/api/v1/custom-taxonomies/{taxonomy_id}",
+        { params: { path: { taxonomy_id: id } } },
+        parseCustomTaxonomy
+      );
+    },
+    async createCustomTaxonomy(body) {
+      return call("POST", "/api/v1/custom-taxonomies", { body }, parseCustomTaxonomy);
+    },
+    async updateCustomTaxonomy(id, body) {
+      return call(
+        "PUT",
+        "/api/v1/custom-taxonomies/{taxonomy_id}",
+        { params: { path: { taxonomy_id: id } }, body },
+        parseCustomTaxonomy
+      );
+    },
+    async deleteCustomTaxonomy(id) {
+      return call(
+        "DELETE",
+        "/api/v1/custom-taxonomies/{taxonomy_id}",
+        { params: { path: { taxonomy_id: id } } },
+        parseEmpty
+      );
+    },
+    async restoreCustomTaxonomy(id) {
+      return call(
+        "POST",
+        "/api/v1/custom-taxonomies/{taxonomy_id}/restore",
+        { params: { path: { taxonomy_id: id } } },
+        parseCustomTaxonomy
+      );
+    },
+    async parseCustomTaxonomyText(body) {
+      return call(
+        "POST",
+        "/api/v1/custom-taxonomies/parse-text",
+        { body },
+        parseTaxonomyTextPreview
+      );
+    },
     // ── Alerts ────────────────────────────────────────────────────
     async listAlerts(filters) {
       return call("GET", "/api/v1/alerts", { params: { query: filters } }, parseAlertPage);
@@ -2254,6 +2590,32 @@ var createApiKeyTool = {
     return ok(result.value);
   }
 };
+var CreateCustomRoleInputShape = {
+  name: z.string().min(1).max(100).describe("Display name for the role."),
+  permissions: z.array(z.string().min(1).max(100)).min(1).max(200).describe(
+    "Permission slugs the role grants (e.g. 'scans.read', 'campaigns.write'). Use `list_org_roles` to see permissions on existing system roles."
+  )
+};
+var createCustomRoleTool = {
+  name: "create_custom_role",
+  description: "Create a custom organization role with the supplied permission set. Returns the persisted role; assign it to users via `update_user_role`.",
+  annotations: {
+    title: "Create Custom Role",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  },
+  inputSchema: z.object(CreateCustomRoleInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.createCustomRole({
+      name: input.name,
+      permissions: [...input.permissions]
+    });
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok(result.value);
+  }
+};
 var GetAccountInputShape = {};
 var getAccountTool = {
   name: "get_account",
@@ -2299,6 +2661,24 @@ var inviteUserTool = {
     return ok(result.value);
   }
 };
+var ListAccountLabelsInputShape = {};
+var listAccountLabelsTool = {
+  name: "list_account_labels",
+  description: "List the organization's custom label definitions (key, display_name, position, auto_extract). Labels enrich scans and can be used as filters in `list_scans`.",
+  annotations: {
+    title: "List Account Labels",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(ListAccountLabelsInputShape),
+  handler: async (_input, ctx) => {
+    const result = await ctx.api.listAccountLabels();
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok({ items: result.value });
+  }
+};
 var ListApiKeysInputShape = {};
 var listApiKeysTool = {
   name: "list_api_keys",
@@ -2413,6 +2793,45 @@ var transferOwnershipTool = {
     return ok({ transferred: true });
   }
 };
+var LabelItem = z.object({
+  key: z.string().min(1).max(100).regex(/^[a-z0-9_]+$/, "key must be snake_case ([a-z0-9_]+)").describe("Stable snake_case identifier used in scan filters."),
+  display_name: z.string().min(1).max(200).describe("Human-readable name shown in the UI."),
+  auto_extract: z.boolean().optional().describe(
+    "When true, the LLM auto-populates this label's value during scan classification. Defaults to false."
+  )
+});
+var UpdateAccountLabelsInputShape = {
+  labels: z.array(LabelItem).max(20).describe(
+    "REPLACEMENT list of all labels \u2014 pass every label you want to keep. Order in the array becomes `position`. Empty array removes all labels."
+  )
+};
+var updateAccountLabelsTool = {
+  name: "update_account_labels",
+  description: "REPLACE the organization's full set of custom label definitions. The API replaces the list (no merge); read the current list with `list_account_labels` first. Returns the persisted list with allocated positions.",
+  annotations: {
+    title: "Update Account Labels",
+    readOnlyHint: false,
+    // REPLACE semantics: passing `labels: []` wipes every label and
+    // detaches the value on every scan that referenced one. Hint as
+    // destructive so MCP clients that gate dangerous tools warn the
+    // user before this call runs.
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(UpdateAccountLabelsInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.updateAccountLabels({
+      labels: input.labels.map((l) => ({
+        key: l.key,
+        display_name: l.display_name,
+        auto_extract: l.auto_extract ?? false
+      }))
+    });
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok({ items: result.value });
+  }
+};
 var UpdateOrgInputShape = {
   name: z.string().min(1).max(200).optional().describe("New organization display name."),
   settings: z.record(z.unknown()).optional().describe("Replacement settings object. Fields not supplied are left unchanged.")
@@ -2574,7 +2993,7 @@ var setCampaignAlertOverridesTool = {
 var GetAlertStatsInputShape = {};
 var getAlertStatsTool = {
   name: "get_alert_stats",
-  description: "Get alert counts grouped by status: open, ack, resolved, ignored, total.",
+  description: "Get alert counts grouped by status: open, acknowledged, resolved, dismissed (total is implicit in the sum). Status names match the canonical AlertStatus enum used by `list_alerts` and `update_alert_status`.",
   annotations: {
     title: "Get Alert Stats",
     readOnlyHint: true,
@@ -2591,13 +3010,15 @@ var getAlertStatsTool = {
 };
 var ListAlertsInputShape = {
   campaign_id: z.string().uuid().optional().describe("Filter to one campaign's alerts."),
-  status: z.enum(["open", "ack", "resolved", "ignored"]).optional().describe("Filter by alert status."),
+  status: z.enum(["open", "acknowledged", "resolved", "dismissed"]).optional().describe(
+    "Filter by alert status. Open = unhandled; acknowledged = seen by an operator; resolved = closed; dismissed = closed without action."
+  ),
   page: z.number().int().min(1).max(500).default(1).describe("1-indexed page number."),
   limit: z.number().int().min(1).max(200).default(50).describe("Page size.")
 };
 var listAlertsTool = {
   name: "list_alerts",
-  description: "List violation alerts (one per scan + violating-tag combo) with offer URL, tag, country, status, scan back-reference.",
+  description: "List violation alerts (one per scan + violating rule combo) with offer URL, country, status, scan back-reference, and the kind-aware fields `rule_type` (tag / iab_v3 / brand / ai_category / custom_taxonomy) + `matched_value` (the canonical text the scan matched against).",
   annotations: {
     title: "List Alerts",
     readOnlyHint: true,
@@ -2675,15 +3096,29 @@ var getUsageSummaryTool = {
     return ok(result.value);
   }
 };
+var TransactionTypeEnum = z.enum([
+  "initial_balance",
+  "top_up_manual",
+  "usage_charge",
+  "subscription_renewal",
+  "subscription_upgrade",
+  "admin_adjustment",
+  "refund",
+  "invoice_settlement",
+  "crypto_top_up"
+]);
 var ListBalanceHistoryInputShape = {
   date_from: z.string().date().optional().describe("ISO date, inclusive."),
   date_to: z.string().date().optional().describe("ISO date, inclusive."),
+  type: z.array(TransactionTypeEnum).max(9).optional().describe(
+    "Filter by transaction kind. Pass several values to OR them (e.g. ['top_up_manual','crypto_top_up'] for credits-only)."
+  ),
   page: z.number().int().min(1).max(500).default(1).describe("1-indexed page."),
   limit: z.number().int().min(1).max(200).default(50).describe("Page size.")
 };
 var listBalanceHistoryTool = {
   name: "list_balance_history",
-  description: "List ledger transactions (charges, refunds, top-ups, invoice settlements) on the organization's balance. Each row: type, amount in micros, description, timestamp.",
+  description: "List ledger transactions (charges, refunds, top-ups, invoice settlements) on the organization's balance. Each row: type, amount in micros, description, timestamp. Filter by `type` (multi-select) and / or date range.",
   annotations: {
     title: "List Balance History",
     readOnlyHint: true,
@@ -2697,7 +3132,8 @@ var listBalanceHistoryTool = {
       page: input.page,
       limit: input.limit,
       ...input.date_from !== void 0 ? { date_from: input.date_from } : {},
-      ...input.date_to !== void 0 ? { date_to: input.date_to } : {}
+      ...input.date_to !== void 0 ? { date_to: input.date_to } : {},
+      ...input.type !== void 0 ? { type: input.type } : {}
     };
     const result = await ctx.api.listBalanceHistory(filters);
     if (result.isErr()) return err(mapApiError(result.error));
@@ -2705,8 +3141,10 @@ var listBalanceHistoryTool = {
   }
 };
 var ListUsageInputShape = {
-  date_from: z.string().date().optional().describe("ISO date (YYYY-MM-DD), inclusive."),
-  date_to: z.string().date().optional().describe("ISO date (YYYY-MM-DD), inclusive."),
+  date_from: z.string().datetime({ offset: true }).optional().describe(
+    "ISO 8601 datetime (with timezone offset), inclusive lower bound on the usage timestamp. Plain dates also work \u2014 the API normalises to UTC midnight."
+  ),
+  date_to: z.string().datetime({ offset: true }).optional().describe("ISO 8601 datetime (with offset), inclusive upper bound."),
   scan_id: z.string().uuid().optional().describe("Filter to one scan's cost rows."),
   page: z.number().int().min(1).max(500).default(1).describe("1-indexed page."),
   limit: z.number().int().min(1).max(200).default(50).describe("Page size.")
@@ -3070,12 +3508,16 @@ var listCampaignRunsTool = {
 };
 var ListCampaignsInputShape = {
   group_id: z.string().uuid().optional().describe("Optional campaign-group UUID to filter by."),
+  archived: z.boolean().optional().describe(
+    "When omitted, the API returns active campaigns only. Pass `true` to see archived campaigns, `false` for active-only (explicit)."
+  ),
+  q: z.string().min(1).max(200).optional().describe("Substring search against campaign name (case-insensitive)."),
   page: z.number().int().min(1).max(500).default(1).describe("1-indexed page number."),
   limit: z.number().int().min(1).max(200).default(50).describe("Page size (1-200).")
 };
 var listCampaignsTool = {
   name: "list_campaigns",
-  description: "List campaigns for the caller's organization, optionally filtered by group, paginated.",
+  description: "List campaigns for the caller's organization, optionally filtered by group, archived flag, or name substring. Paginated.",
   annotations: {
     title: "List Campaigns",
     readOnlyHint: true,
@@ -3088,14 +3530,21 @@ var listCampaignsTool = {
     const filters = {
       page: input.page,
       limit: input.limit,
-      ...input.group_id !== void 0 ? { group_id: input.group_id } : {}
+      ...input.group_id !== void 0 ? { group_id: input.group_id } : {},
+      ...input.archived !== void 0 ? { archived: input.archived } : {},
+      ...input.q !== void 0 ? { q: input.q } : {}
     };
     const result = await ctx.api.listCampaigns(filters);
     if (result.isErr()) return err(mapApiError(result.error));
     return ok(result.value);
   }
 };
-var ListCampaignsPickerInputShape = {};
+var ListCampaignsPickerInputShape = {
+  archived: z.boolean().optional().describe("Pass true to include archived campaigns. Defaults to active-only."),
+  group_id: z.string().uuid().optional().describe("Filter to one campaign group."),
+  q: z.string().min(1).max(200).optional().describe("Substring search against campaign name (case-insensitive)."),
+  limit: z.number().int().min(1).max(500).optional().describe("Maximum rows to return (default per API, typically 200).")
+};
 var listCampaignsPickerTool = {
   name: "list_campaigns_picker",
   description: "Slim per-row campaign list for selection UIs \u2014 id, name, group_id, is_archived. Cheaper than `list_campaigns` for orgs with thousands of campaigns. Use `get_campaign(id)` after a selection to fetch full details.",
@@ -3107,8 +3556,16 @@ var listCampaignsPickerTool = {
     openWorldHint: false
   },
   inputSchema: z.object(ListCampaignsPickerInputShape),
-  handler: async (_input, ctx) => {
-    const result = await ctx.api.listCampaignsPicker();
+  handler: async (input, ctx) => {
+    const filters = {
+      ...input.archived !== void 0 ? { archived: input.archived } : {},
+      ...input.group_id !== void 0 ? { group_id: input.group_id } : {},
+      ...input.q !== void 0 ? { q: input.q } : {},
+      ...input.limit !== void 0 ? { limit: input.limit } : {}
+    };
+    const result = await ctx.api.listCampaignsPicker(
+      Object.keys(filters).length > 0 ? filters : void 0
+    );
     if (result.isErr()) return err(mapApiError(result.error));
     return ok(result.value);
   }
@@ -3340,6 +3797,196 @@ var updateCustomRuleTool = {
     return ok(result.value);
   }
 };
+var TaxonomyNodeShape = z.object({
+  client_id: z.string().min(1).max(100).describe(
+    "Caller-chosen string id used to wire parent/child links inside this request only. The API allocates real UUIDs on response."
+  ),
+  parent_client_id: z.string().min(1).max(100).nullable().optional().describe("client_id of this node's parent. null/omitted = top-level node."),
+  name: z.string().min(1).max(100).describe("Display name of the node."),
+  description: z.string().max(200).optional().describe(
+    "Free-form description shown to the LLM during classification \u2014 keep it concrete (one sentence)."
+  ),
+  is_default: z.boolean().optional().describe(
+    "Mark this node as the fallback bucket. Exactly ONE node per taxonomy must be is_default=true."
+  )
+});
+
+// src/application/tools/custom-taxonomies/create-custom-taxonomy.tool.ts
+var CreateCustomTaxonomyInputShape = {
+  name: z.string().min(1).max(100).describe("Display name (1-100 chars)."),
+  description: z.string().max(500).optional().describe("Free-form description (defaults to empty string)."),
+  nodes: z.array(TaxonomyNodeShape).max(2e3).optional().describe(
+    "Initial tree as a flat array (parents before children, linked via client_id / parent_client_id). Empty / omitted = empty taxonomy."
+  )
+};
+var createCustomTaxonomyTool = {
+  name: "create_custom_taxonomy",
+  description: "Create a custom classification taxonomy with its initial tree. Exactly one node should have is_default=true (fallback for scans the LLM cannot classify confidently). Returns the persisted taxonomy with allocated node UUIDs and version=1.",
+  annotations: {
+    title: "Create Custom Taxonomy",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  },
+  inputSchema: z.object(CreateCustomTaxonomyInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.createCustomTaxonomy({
+      name: input.name,
+      description: input.description ?? "",
+      nodes: (input.nodes ?? []).map(toRequestNode)
+    });
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok(result.value);
+  }
+};
+function toRequestNode(n) {
+  return {
+    client_id: n.client_id,
+    parent_client_id: n.parent_client_id ?? null,
+    name: n.name,
+    description: n.description ?? "",
+    is_default: n.is_default ?? false
+  };
+}
+var DeleteCustomTaxonomyInputShape = {
+  taxonomy_id: z.string().uuid().describe("Custom taxonomy UUID.")
+};
+var deleteCustomTaxonomyTool = {
+  name: "delete_custom_taxonomy",
+  description: "Soft-delete a custom taxonomy (sets is_active=false). Historical scan classifications keep referencing the id; new scans skip this taxonomy. Use `restore_custom_taxonomy` to undo.",
+  annotations: {
+    title: "Delete Custom Taxonomy",
+    readOnlyHint: false,
+    destructiveHint: true,
+    // Soft-delete: a second call returns 404 for the same id but
+    // does not change observable state — same convention used by
+    // `delete_policy_set` and `delete_tag_definition`.
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(DeleteCustomTaxonomyInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.deleteCustomTaxonomy(input.taxonomy_id);
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok({ deleted: true });
+  }
+};
+var GetCustomTaxonomyInputShape = {
+  taxonomy_id: z.string().uuid().describe("Custom taxonomy UUID.")
+};
+var getCustomTaxonomyTool = {
+  name: "get_custom_taxonomy",
+  description: "Get one custom taxonomy by UUID with its full node tree (each node has id, parent_id, level, position, name, description, is_default).",
+  annotations: {
+    title: "Get Custom Taxonomy",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(GetCustomTaxonomyInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.getCustomTaxonomy(input.taxonomy_id);
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok(result.value);
+  }
+};
+var ListCustomTaxonomiesInputShape = {};
+var listCustomTaxonomiesTool = {
+  name: "list_custom_taxonomies",
+  description: "List the calling org's custom classification taxonomies. Returns slim summaries (id, name, slug, version, node_count, is_active). Soft-deleted taxonomies are included with `is_active=false`. Fetch the full tree via `get_custom_taxonomy`.",
+  annotations: {
+    title: "List Custom Taxonomies",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(ListCustomTaxonomiesInputShape),
+  handler: async (_input, ctx) => {
+    const result = await ctx.api.listCustomTaxonomies();
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok({ items: result.value });
+  }
+};
+var ParseCustomTaxonomyTextInputShape = {
+  text: z.string().min(1).max(5e4).describe(
+    "Free-form text describing the tree (one node per line; indentation expresses depth). Up to 50 000 chars."
+  )
+};
+var parseCustomTaxonomyTextTool = {
+  name: "parse_custom_taxonomy_text",
+  description: "Preview-parse pasted free-form text into a taxonomy tree (NOT persisted). Returns `nodes: [{level, name, description}]` + `warnings: string[]`. After review, persist via `create_custom_taxonomy` (remember to flag exactly one node as is_default).",
+  annotations: {
+    title: "Parse Custom Taxonomy Text",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(ParseCustomTaxonomyTextInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.parseCustomTaxonomyText({ text: input.text });
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok(result.value);
+  }
+};
+var RestoreCustomTaxonomyInputShape = {
+  taxonomy_id: z.string().uuid().describe("Custom taxonomy UUID (must currently be is_active=false).")
+};
+var restoreCustomTaxonomyTool = {
+  name: "restore_custom_taxonomy",
+  description: "Re-activate a previously soft-deleted custom taxonomy. Returns the restored taxonomy with its full tree (is_active=true).",
+  annotations: {
+    title: "Restore Custom Taxonomy",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(RestoreCustomTaxonomyInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.restoreCustomTaxonomy(input.taxonomy_id);
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok(result.value);
+  }
+};
+var UpdateCustomTaxonomyInputShape = {
+  taxonomy_id: z.string().uuid().describe("Custom taxonomy UUID."),
+  name: z.string().min(1).max(100).describe("New display name."),
+  description: z.string().max(500).optional().describe("New description (defaults to empty string)."),
+  nodes: z.array(TaxonomyNodeShape).max(2e3).optional().describe(
+    "REPLACEMENT tree as a flat array (REPLACES the existing tree, not a merge). Read the current tree via `get_custom_taxonomy` first if you only want to tweak one node."
+  )
+};
+var updateCustomTaxonomyTool = {
+  name: "update_custom_taxonomy",
+  description: "REPLACE a custom taxonomy's name, description, and full tree atomically. The API bumps `version` on every successful update; ongoing scan classifications continue with the previous tree until they finish, so updates are safe but not retroactive.",
+  annotations: {
+    title: "Update Custom Taxonomy",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(UpdateCustomTaxonomyInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.updateCustomTaxonomy(input.taxonomy_id, {
+      name: input.name,
+      description: input.description ?? "",
+      nodes: (input.nodes ?? []).map((n) => ({
+        client_id: n.client_id,
+        parent_client_id: n.parent_client_id ?? null,
+        name: n.name,
+        description: n.description ?? "",
+        is_default: n.is_default ?? false
+      }))
+    });
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok(result.value);
+  }
+};
 var ListEmulatorsInputShape = {};
 var listEmulatorsTool = {
   name: "list_emulators",
@@ -3378,13 +4025,72 @@ var listGeosTool = {
     return ok({ items: result.value, total: result.value.length });
   }
 };
+
+// src/application/tools/_shared/binary-content.ts
+function imageBlock(bytes, mimeType) {
+  return {
+    content: [
+      {
+        type: "image",
+        data: Buffer.from(bytes).toString("base64"),
+        mimeType
+      }
+    ]
+  };
+}
+function resourceBlock(bytes, mimeType, uri) {
+  return {
+    content: [
+      {
+        type: "resource",
+        resource: {
+          uri,
+          mimeType,
+          blob: Buffer.from(bytes).toString("base64")
+        }
+      }
+    ]
+  };
+}
+
+// src/application/tools/invoicing/get-invoice-pdf.tool.ts
+var GetInvoicePdfInputShape = {
+  invoice_id: z.string().uuid().describe("Invoice UUID \u2014 see `list_invoices`.")
+};
+var getInvoicePdfTool = {
+  name: "get_invoice_pdf",
+  description: "Download one invoice as an inline PDF (base64-encoded). Returned as a single MCP resource content block \u2014 agents can save / forward it without a second API call.",
+  annotations: {
+    title: "Get Invoice PDF",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(GetInvoicePdfInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.getInvoicePdf(input.invoice_id);
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok(
+      resourceBlock(
+        result.value.bytes,
+        result.value.contentType,
+        `kaminari-ad://invoices/${input.invoice_id}.pdf`
+      )
+    );
+  }
+};
 var ListInvoicesInputShape = {
+  type: z.enum(["proforma", "final"]).optional().describe(
+    "Filter by invoice kind: proforma (advance bill) or final (issued after the period)."
+  ),
+  status: z.enum(["draft", "issued", "paid", "voided", "overdue"]).optional().describe("Filter by lifecycle status."),
   page: z.number().int().min(1).max(500).default(1).describe("1-indexed page."),
   limit: z.number().int().min(1).max(200).default(50).describe("Page size.")
 };
 var listInvoicesTool = {
   name: "list_invoices",
-  description: "List invoices issued to the organization with number, status, total in micros, currency, due/paid dates. Use to find an invoice id; PDFs are available at https://app.kaminari.ad/api/v1/invoices/{id}/pdf (not exposed via MCP \u2014 agents return the URL to the user).",
+  description: "List invoices issued to the organization with number, type, status, total in micros, currency, due/paid dates. Filter by `type` and / or `status`. Use `get_invoice_pdf` to download the PDF for a specific invoice.",
   annotations: {
     title: "List Invoices",
     readOnlyHint: true,
@@ -3394,23 +4100,123 @@ var listInvoicesTool = {
   },
   inputSchema: z.object(ListInvoicesInputShape),
   handler: async (input, ctx) => {
-    const result = await ctx.api.listInvoices({ page: input.page, limit: input.limit });
+    const filters = {
+      page: input.page,
+      limit: input.limit,
+      ...input.type !== void 0 ? { type: input.type } : {},
+      ...input.status !== void 0 ? { status: input.status } : {}
+    };
+    const result = await ctx.api.listInvoices(filters);
     if (result.isErr()) return err(mapApiError(result.error));
     return ok(result.value);
   }
 };
-var PolicyEntryShape = z.object({
-  tag_slug: z.string().min(1).max(100).describe("Tag slug that triggers a violation."),
-  country_codes: z.array(z.string().length(2)).max(50).describe("Restrict the violation to these countries. Empty array = all countries.")
+var TIER1 = z.string().min(1).max(200);
+var TIER_OPT = z.string().max(200).nullable().optional();
+var IabV3Block = z.object({
+  tier1: TIER1.describe("Top-level IAB Content Taxonomy V3 category (e.g. 'Sensitive Topics')."),
+  tier2: TIER_OPT.describe("Sub-category (optional). Empty/null = subtree match."),
+  tier3: TIER_OPT.describe("Sub-sub-category (optional)."),
+  tier4: TIER_OPT.describe(
+    "Leaf-level category (optional). When all 4 tiers set, leaf-only match."
+  )
+});
+var AiCategoryBlock = z.object({
+  tier1: TIER1.describe("Top-level freeform AI-generated category (e.g. 'Gambling')."),
+  tier2: TIER_OPT.describe("Sub-category (optional)."),
+  tier3: TIER_OPT.describe("Sub-sub-category (optional)."),
+  tier4: TIER_OPT.describe("Leaf-level category (optional).")
+});
+var CustomTaxonomyBlock = z.object({
+  taxonomy_id: z.string().uuid().describe("ID of the per-org custom taxonomy (see `list_custom_taxonomies`)."),
+  tier1: TIER1.describe("Top-level node name in the taxonomy."),
+  tier2: TIER_OPT.describe("Tier 2 node name (optional)."),
+  tier3: TIER_OPT.describe("Tier 3 node name (optional)."),
+  tier4: TIER_OPT.describe("Leaf node name (optional).")
 });
+var COUNTRY_CODES = z.array(z.string().min(2).max(3)).max(50).describe("Restrict the rule to these countries (ISO 3166-1 alpha-2 / alpha-3). Empty = all.");
+var PolicyEntryInput = z.discriminatedUnion("rule_type", [
+  z.object({
+    rule_type: z.literal("tag").describe("Match a specific tag slug emitted by the scan pipeline."),
+    tag_slug: z.string().min(1).max(100).describe("Tag slug (see `list_tags` for the catalogue)."),
+    country_codes: COUNTRY_CODES
+  }),
+  z.object({
+    rule_type: z.literal("iab_v3").describe("Match the scan's canonical IAB V3 category prefix."),
+    iab_v3: IabV3Block,
+    country_codes: COUNTRY_CODES
+  }),
+  z.object({
+    rule_type: z.literal("brand").describe("Match the scan's advertiser brand (case-insensitive)."),
+    brand: z.string().min(1).max(200).describe("Brand string."),
+    country_codes: COUNTRY_CODES
+  }),
+  z.object({
+    rule_type: z.literal("ai_category").describe("Match the freeform LLM-generated category prefix on the scan."),
+    ai_category: AiCategoryBlock,
+    country_codes: COUNTRY_CODES
+  }),
+  z.object({
+    rule_type: z.literal("custom_taxonomy").describe("Match a per-org custom taxonomy node prefix on the scan."),
+    custom_taxonomy: CustomTaxonomyBlock,
+    country_codes: COUNTRY_CODES
+  })
+]).describe(
+  "One policy rule. Discriminated by `rule_type`; populate the matching value-block (tag_slug / iab_v3 / brand / ai_category / custom_taxonomy)."
+);
+function policyEntryToRequest(entry) {
+  const base = {
+    rule_type: entry.rule_type,
+    tag_slug: null,
+    iab_v3: null,
+    brand: null,
+    ai_category: null,
+    custom_taxonomy: null,
+    country_codes: [...entry.country_codes]
+  };
+  if (entry.rule_type === "tag") {
+    return { ...base, tag_slug: entry.tag_slug };
+  }
+  if (entry.rule_type === "iab_v3") {
+    return { ...base, iab_v3: normaliseTiers(entry.iab_v3) };
+  }
+  if (entry.rule_type === "brand") {
+    return { ...base, brand: entry.brand };
+  }
+  if (entry.rule_type === "ai_category") {
+    return { ...base, ai_category: normaliseTiers(entry.ai_category) };
+  }
+  return { ...base, custom_taxonomy: normaliseCustomTaxonomy(entry.custom_taxonomy) };
+}
+function normaliseTiers(t) {
+  return {
+    tier1: t.tier1,
+    tier2: t.tier2 ?? null,
+    tier3: t.tier3 ?? null,
+    tier4: t.tier4 ?? null
+  };
+}
+function normaliseCustomTaxonomy(t) {
+  return {
+    taxonomy_id: t.taxonomy_id,
+    tier1: t.tier1,
+    tier2: t.tier2 ?? null,
+    tier3: t.tier3 ?? null,
+    tier4: t.tier4 ?? null
+  };
+}
+
+// src/application/tools/policy-sets/create-policy-set.tool.ts
 var CreatePolicySetInputShape = {
   name: z.string().min(1).max(200).describe("Display name."),
   description: z.string().max(2e3).describe("Free-form description (use empty string for none)."),
-  entries: z.array(PolicyEntryShape).min(1).max(500).describe("At least one entry. Each entry pairs a tag-slug with country codes.")
+  entries: z.array(PolicyEntryInput).min(1).max(500).describe(
+    "At least one entry. Each entry is a discriminated union over five rule kinds: tag / iab_v3 / brand / ai_category / custom_taxonomy."
+  )
 };
 var createPolicySetTool = {
   name: "create_policy_set",
-  description: "Create a new policy set (named collection of tag + country-list entries). Once created, you can bind campaigns to it via `update_campaign`.",
+  description: "Create a new policy set (named collection of violation rules). Each rule is one of: tag slug, IAB V3 category prefix, advertiser brand, freeform AI category, or per-org custom-taxonomy node. Bind campaigns to the set via `update_campaign`.",
   annotations: {
     title: "Create Policy Set",
     readOnlyHint: false,
@@ -3423,7 +4229,7 @@ var createPolicySetTool = {
     const result = await ctx.api.createPolicySet({
       name: input.name,
       description: input.description,
-      entries: input.entries.map((e) => ({ tag_slug: e.tag_slug, country_codes: e.country_codes }))
+      entries: input.entries.map(policyEntryToRequest)
     });
     if (result.isErr()) return err(mapApiError(result.error));
     return ok(result.value);
@@ -3454,7 +4260,7 @@ var GetPolicySetInputShape = {
 };
 var getPolicySetTool = {
   name: "get_policy_set",
-  description: "Get one policy set by UUID with its complete list of entries (tag-slug + applicable country codes).",
+  description: "Get one policy set by UUID with its complete list of entries (each entry is one of five rule kinds \u2014 tag / iab_v3 / brand / ai_category / custom_taxonomy \u2014 plus applicable country codes).",
   annotations: {
     title: "Get Policy Set",
     readOnlyHint: true,
@@ -3471,11 +4277,14 @@ var getPolicySetTool = {
 };
 var ListPolicySetsInputShape = {
   page: z.number().int().min(1).max(500).default(1).describe("1-indexed page number."),
-  limit: z.number().int().min(1).max(200).default(50).describe("Page size.")
+  limit: z.number().int().min(1).max(200).default(50).describe("Page size."),
+  visibility: z.enum(["private", "public"]).optional().describe(
+    "Narrow to one scope. `private` = org-owned only, `public` = Kaminari Ad-curated sets visible to every org. Omit the filter to see BOTH combined."
+  )
 };
 var listPolicySetsTool = {
   name: "list_policy_sets",
-  description: "Paginated list of policy sets: named collections of (tag, country-list) entries that define what counts as a violation. Campaigns bind to one policy set. Returns `{items, total, page, limit}`. List items omit `entries` for payload size \u2014 fetch a single set via `get_policy_set` when you need them.",
+  description: "Paginated list of policy sets: named collections of violation rules (tag / IAB V3 / brand / AI category / custom-taxonomy entries) that define what counts as a violation. Campaigns bind to one policy set. Returns `{items, total, page, limit}`. List items omit `entries` for payload size \u2014 fetch a single set via `get_policy_set` when you need them. Use `visibility=public` to discover Kaminari Ad-curated sets.",
   annotations: {
     title: "List Policy Sets",
     readOnlyHint: true,
@@ -3485,7 +4294,11 @@ var listPolicySetsTool = {
   },
   inputSchema: z.object(ListPolicySetsInputShape),
   handler: async (input, ctx) => {
-    const result = await ctx.api.listPolicySets({ page: input.page, limit: input.limit });
+    const result = await ctx.api.listPolicySets({
+      page: input.page,
+      limit: input.limit,
+      ...input.visibility !== void 0 ? { visibility: input.visibility } : {}
+    });
     if (result.isErr()) return err(mapApiError(result.error));
     return ok(result.value);
   }
@@ -3510,19 +4323,17 @@ var requestPolicySetApprovalTool = {
     return ok({ requested: true });
   }
 };
-var PolicyEntryShape2 = z.object({
-  tag_slug: z.string().min(1).max(100),
-  country_codes: z.array(z.string().length(2)).max(50)
-});
 var UpdatePolicySetInputShape = {
   policy_set_id: z.string().uuid().describe("Policy set UUID."),
   name: z.string().min(1).max(200).describe("New name (always required by the API on update)."),
   description: z.string().max(2e3).describe("New description (empty string allowed)."),
-  entries: z.array(PolicyEntryShape2).min(1).max(500).describe("REPLACEMENT entries list \u2014 REPLACES the current list, not a merge.")
+  entries: z.array(PolicyEntryInput).min(1).max(500).describe(
+    "REPLACEMENT entries list \u2014 REPLACES the current list, not a merge. Each entry is a discriminated union over five rule kinds (tag / iab_v3 / brand / ai_category / custom_taxonomy)."
+  )
 };
 var updatePolicySetTool = {
   name: "update_policy_set",
-  description: "REPLACE a policy set's name, description, and entry list. The API requires all three fields on every update \u2014 read the current set with `get_policy_set` first if you only want to change one thing.",
+  description: "REPLACE a policy set's name, description, and entry list. The API requires all three fields on every update \u2014 read the current set with `get_policy_set` first if you only want to change one thing. Supports all five rule kinds (tag / iab_v3 / brand / ai_category / custom_taxonomy).",
   annotations: {
     title: "Update Policy Set",
     readOnlyHint: false,
@@ -3535,7 +4346,7 @@ var updatePolicySetTool = {
     const result = await ctx.api.updatePolicySet(input.policy_set_id, {
       name: input.name,
       description: input.description,
-      entries: input.entries.map((e) => ({ tag_slug: e.tag_slug, country_codes: e.country_codes }))
+      entries: input.entries.map(policyEntryToRequest)
     });
     if (result.isErr()) return err(mapApiError(result.error));
     return ok(result.value);
@@ -3708,22 +4519,110 @@ var getScanTool = {
     return ok(result.value);
   }
 };
+var GetScanCreativeScreenshotInputShape = {
+  scan_id: z.string().uuid().describe("Scan UUID \u2014 must be an ad-tag scan (is_ad_tag=true)."),
+  width: z.number().int().min(50).max(2e3).optional().describe("Optional resize width in pixels.")
+};
+var getScanCreativeScreenshotTool = {
+  name: "get_scan_creative_screenshot",
+  description: "Fetch the creative screenshot for an ad-tag scan as an inline image (base64-encoded PNG). Returns 404 if the scan is not an ad-tag scan or has no creative captured yet.",
+  annotations: {
+    title: "Get Scan Creative Screenshot",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(GetScanCreativeScreenshotInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.getScanCreativeScreenshot(input.scan_id, input.width);
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok(imageBlock(result.value.bytes, result.value.contentType));
+  }
+};
+var GetScanLandingScreenshotInputShape = {
+  scan_id: z.string().uuid().describe("Scan UUID (ad-tag scan)."),
+  landing_ord: z.number().int().min(0).max(50).describe("0-indexed landing slot (see `get_scan(...).landings[*].ord`)."),
+  width: z.number().int().min(50).max(2e3).optional().describe("Optional resize width in pixels.")
+};
+var getScanLandingScreenshotTool = {
+  name: "get_scan_landing_screenshot",
+  description: "Fetch the screenshot of one landing tab on an ad-tag scan as an inline image. Use `get_scan` first to discover available `landings[*].ord` values.",
+  annotations: {
+    title: "Get Scan Landing Screenshot",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(GetScanLandingScreenshotInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.getScanLandingScreenshot(
+      input.scan_id,
+      input.landing_ord,
+      input.width
+    );
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok(imageBlock(result.value.bytes, result.value.contentType));
+  }
+};
+var GetScanScreenshotInputShape = {
+  scan_id: z.string().uuid().describe("Scan UUID."),
+  width: z.number().int().min(50).max(2e3).optional().describe(
+    "Optional resize width in pixels. The API resizes server-side to keep the image small for the agent's context window."
+  )
+};
+var getScanScreenshotTool = {
+  name: "get_scan_screenshot",
+  description: "Fetch the primary screenshot for a scan as an inline image (base64-encoded PNG). Pass `width` to request a resized version (50-2000 px). Returns one MCP image content block.",
+  annotations: {
+    title: "Get Scan Screenshot",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: z.object(GetScanScreenshotInputShape),
+  handler: async (input, ctx) => {
+    const result = await ctx.api.getScanScreenshot(input.scan_id, input.width);
+    if (result.isErr()) return err(mapApiError(result.error));
+    return ok(imageBlock(result.value.bytes, result.value.contentType));
+  }
+};
 var ListScansInputShape = {
   status: z.string().optional().describe(
-    "Comma-separated statuses to filter by. One of: pending, running, done, failed, cancelled."
+    "Comma-separated statuses to filter by. Lifecycle values: pending, running, crawled, checking, checking_async, completed, partial, failed, cancelled."
   ),
   country_code: z.string().optional().describe("Comma-separated ISO 3166-1 alpha-2 country codes, e.g. US,DE,JP."),
   url: z.string().optional().describe("Substring match against the scanned URL."),
   scan_id: z.string().optional().describe("Comma-separated scan UUIDs to fetch a specific set."),
   date_from: z.string().date().optional().describe("ISO date (YYYY-MM-DD), inclusive lower bound on scan creation."),
   date_to: z.string().date().optional().describe("ISO date (YYYY-MM-DD), inclusive upper bound on scan creation."),
+  timezone: z.string().optional().describe(
+    "IANA timezone (e.g. 'Europe/Berlin') applied to date_from / date_to. Defaults to UTC."
+  ),
+  run_id: z.string().uuid().optional().describe("Filter to scans of one run."),
+  campaign_id: z.string().uuid().optional().describe("Filter to scans of one campaign."),
+  group_id: z.string().uuid().optional().describe("Filter to scans of one campaign group."),
   tag: z.string().optional().describe("Comma-separated tag slugs to filter by."),
+  ai_category: z.string().optional().describe(
+    "Filter by the freeform LLM-generated category prefix on the scan (slash-separated tier path, e.g. 'Gambling/Online Casinos')."
+  ),
+  iab_v3_category: z.string().optional().describe("Filter by canonical IAB Content Taxonomy V3 prefix (slash-separated tier path)."),
+  iab_category: z.string().optional().describe("Filter by legacy IAB V2.2 category (only present on pre-P3 scans)."),
+  brand: z.string().optional().describe("Filter by detected advertiser brand (case-insensitive)."),
+  labels: z.record(
+    z.string().min(1).max(100).regex(/^[a-z0-9_]+$/, "label keys must be snake_case ([a-z0-9_]+)"),
+    z.string().min(1).max(200)
+  ).optional().describe(
+    "Dynamic label filters as a flat object: { brand_safety: 'high', vertical: 'gambling' }. Keys are snake_case and must exist in the org's label catalogue. Each key becomes a `label_<key>=<value>` query param. See `list_account_labels`."
+  ),
   page: z.number().int().min(1).max(500).default(1).describe("1-indexed page number."),
   limit: z.number().int().min(1).max(200).default(50).describe("Page size (1-200). Default 50.")
 };
 var listScansTool = {
   name: "list_scans",
-  description: "List scans for the caller's organization with optional filters (status, country, URL substring, date range, tags). Returns a paginated envelope.",
+  description: "List scans for the caller's organization with optional filters (status, country, URL substring, date range, run/campaign/group, tag, AI/IAB/brand category, dynamic labels). Returns a paginated envelope.",
   annotations: {
     title: "List Scans",
     readOnlyHint: true,
@@ -3733,6 +4632,12 @@ var listScansTool = {
   },
   inputSchema: z.object(ListScansInputShape),
   handler: async (input, ctx) => {
+    const labelFilters = {};
+    if (input.labels !== void 0) {
+      for (const [k, v] of Object.entries(input.labels)) {
+        labelFilters[`label_${k}`] = v;
+      }
+    }
     const filters = {
       page: input.page,
       limit: input.limit,
@@ -3742,7 +4647,16 @@ var listScansTool = {
       ...input.scan_id !== void 0 ? { scan_id: input.scan_id } : {},
       ...input.date_from !== void 0 ? { date_from: input.date_from } : {},
       ...input.date_to !== void 0 ? { date_to: input.date_to } : {},
-      ...input.tag !== void 0 ? { tag: input.tag } : {}
+      ...input.timezone !== void 0 ? { timezone: input.timezone } : {},
+      ...input.run_id !== void 0 ? { run_id: input.run_id } : {},
+      ...input.campaign_id !== void 0 ? { campaign_id: input.campaign_id } : {},
+      ...input.group_id !== void 0 ? { group_id: input.group_id } : {},
+      ...input.tag !== void 0 ? { tag: input.tag } : {},
+      ...input.ai_category !== void 0 ? { ai_category: input.ai_category } : {},
+      ...input.iab_v3_category !== void 0 ? { iab_v3_category: input.iab_v3_category } : {},
+      ...input.iab_category !== void 0 ? { iab_category: input.iab_category } : {},
+      ...input.brand !== void 0 ? { brand: input.brand } : {},
+      ...labelFilters
     };
     const result = await ctx.api.listScans(filters);
     if (result.isErr()) {
@@ -3839,10 +4753,14 @@ var listScanTagsTool = {
     return ok({ items: result.value, total: result.value.length });
   }
 };
-var ListTagsInputShape = {};
+var ListTagsInputShape = {
+  category: z.string().min(1).max(100).optional().describe(
+    "Filter to tags in one category slug (e.g. 'security', 'malware', 'compliance'). Use the slug exactly as it appears in `category` of an existing tag."
+  )
+};
 var listTagsTool = {
   name: "list_tags",
-  description: "List every tag definition the platform knows (system tags + organization custom tags) with category, severity, and usage counters (scans + rules per tag).",
+  description: "List every tag definition the platform knows (system tags + organization custom tags) with category, severity, visibility, and usage counters (scans + rules per tag). Optionally filter by category.",
   annotations: {
     title: "List Tags",
     readOnlyHint: true,
@@ -3851,8 +4769,9 @@ var listTagsTool = {
     openWorldHint: false
   },
   inputSchema: z.object(ListTagsInputShape),
-  handler: async (_input, ctx) => {
-    const result = await ctx.api.listTags();
+  handler: async (input, ctx) => {
+    const filters = input.category !== void 0 ? { category: input.category } : void 0;
+    const result = await ctx.api.listTags(filters);
     if (result.isErr()) return err(mapApiError(result.error));
     return ok({ items: result.value, total: result.value.length });
   }
@@ -3862,7 +4781,9 @@ var UpdateTagDefinitionInputShape = {
   display_name: z.string().min(1).max(200).optional().describe("New human-readable name."),
   description: z.string().max(2e3).optional().describe("New description."),
   severity: z.enum(["high", "medium", "low"]).optional().describe("New severity level."),
-  show_in_public_report: z.boolean().optional().describe("Whether the tag appears in the public scan-report view.")
+  visibility: z.enum(["hidden", "internal", "public"]).optional().describe(
+    "Tag visibility on the scan report: hidden = not surfaced; internal = visible to org members; public = appears in the public scan-share view."
+  )
 };
 var updateTagDefinitionTool = {
   name: "update_tag_definition",
@@ -3880,8 +4801,12 @@ var updateTagDefinitionTool = {
     if (input.display_name !== void 0) body.display_name = input.display_name;
     if (input.description !== void 0) body.description = input.description;
     if (input.severity !== void 0) body.severity = input.severity;
-    if (input.show_in_public_report !== void 0) {
-      body.show_in_public_report = input.show_in_public_report;
+    if (input.visibility !== void 0) body.visibility = input.visibility;
+    if (Object.keys(body).length === 0) {
+      return err({
+        kind: "invalid-input",
+        message: "update_tag_definition requires at least one field to change (display_name, description, severity, or visibility)."
+      });
     }
     const result = await ctx.api.updateTagDefinition(input.slug, body);
     if (result.isErr()) return err(mapApiError(result.error));
@@ -3985,12 +4910,15 @@ var getWebhookTool = {
 };
 var ListWebhookDeliveriesInputShape = {
   webhook_id: z.string().uuid().describe("Webhook endpoint UUID."),
+  success: z.boolean().optional().describe("Filter to delivered (true) or failed (false) attempts only."),
+  from_ts: z.string().datetime({ offset: true }).optional().describe("ISO 8601 datetime (with offset), inclusive lower bound on attempt time."),
+  to_ts: z.string().datetime({ offset: true }).optional().describe("ISO 8601 datetime (with offset), inclusive upper bound."),
   page: z.number().int().min(1).max(500).default(1).describe("1-indexed page."),
   limit: z.number().int().min(1).max(200).default(50).describe("Page size.")
 };
 var listWebhookDeliveriesTool = {
   name: "list_webhook_deliveries",
-  description: "List delivery attempts for one webhook endpoint with event type, status (pending / delivered / failed), HTTP response status if any, and attempt timestamp. Paginated.",
+  description: "List delivery attempts for one webhook endpoint with event type, status (pending / delivered / failed), HTTP response status if any, and attempt timestamp. Filter by `success` and / or a `from_ts` / `to_ts` range. Paginated.",
   annotations: {
     title: "List Webhook Deliveries",
     readOnlyHint: true,
@@ -4000,10 +4928,14 @@ var listWebhookDeliveriesTool = {
   },
   inputSchema: z.object(ListWebhookDeliveriesInputShape),
   handler: async (input, ctx) => {
-    const result = await ctx.api.listWebhookDeliveries(input.webhook_id, {
+    const filters = {
       page: input.page,
-      limit: input.limit
-    });
+      limit: input.limit,
+      ...input.success !== void 0 ? { success: input.success } : {},
+      ...input.from_ts !== void 0 ? { from_ts: input.from_ts } : {},
+      ...input.to_ts !== void 0 ? { to_ts: input.to_ts } : {}
+    };
+    const result = await ctx.api.listWebhookDeliveries(input.webhook_id, filters);
     if (result.isErr()) return err(mapApiError(result.error));
     return ok(result.value);
   }
@@ -4146,6 +5078,9 @@ function registerAllTools(register) {
   register(removeUserTool);
   register(transferOwnershipTool);
   register(listOrgRolesTool);
+  register(createCustomRoleTool);
+  register(listAccountLabelsTool);
+  register(updateAccountLabelsTool);
   register(listApiKeysTool);
   register(createApiKeyTool);
   register(revokeApiKeyTool);
@@ -4157,6 +5092,9 @@ function registerAllTools(register) {
   register(createBulkScansTool);
   register(createScanTool);
   register(recheckScansTool);
+  register(getScanScreenshotTool);
+  register(getScanCreativeScreenshotTool);
+  register(getScanLandingScreenshotTool);
   register(getCampaignTool);
   register(listCampaignsTool);
   register(archiveCampaignTool);
@@ -4191,6 +5129,13 @@ function registerAllTools(register) {
   register(updateCustomRuleTool);
   register(deleteCustomRuleTool);
   register(testCustomRuleTool);
+  register(listCustomTaxonomiesTool);
+  register(getCustomTaxonomyTool);
+  register(createCustomTaxonomyTool);
+  register(updateCustomTaxonomyTool);
+  register(deleteCustomTaxonomyTool);
+  register(restoreCustomTaxonomyTool);
+  register(parseCustomTaxonomyTextTool);
   register(listPolicySetsTool);
   register(getPolicySetTool);
   register(createPolicySetTool);
@@ -4216,6 +5161,7 @@ function registerAllTools(register) {
   register(getUsageSummaryTool);
   register(listBalanceHistoryTool);
   register(listInvoicesTool);
+  register(getInvoicePdfTool);
   register(listAlertDestinationsTool);
   register(deleteAlertDestinationTool);
   register(setAlertDestinationVersionTool);
@@ -4253,12 +5199,28 @@ function wireToolsIntoMcpServer(server, ctxProvider) {
   });
 }
 function toolOkToMcpResult(value) {
+  if (isMcpContentEnvelope(value)) {
+    return value;
+  }
   const isPlainObject = value !== null && typeof value === "object" && !Array.isArray(value);
   return {
     content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
     ...isPlainObject ? { structuredContent: value } : {}
   };
 }
+function isBinaryBlockType(type2) {
+  return type2 === "image" || type2 === "audio" || type2 === "resource";
+}
+function isMcpContentEnvelope(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const v = value;
+  if (!Array.isArray(v.content) || v.content.length === 0) return false;
+  return v.content.every((block) => {
+    if (block === null || typeof block !== "object") return false;
+    const type2 = block.type;
+    return typeof type2 === "string" && isBinaryBlockType(type2);
+  });
+}
 function toolErrorToMcpResult(error) {
   return {
     isError: true,
@@ -4285,5 +5247,5 @@ function formatToolError(error) {
 }
 
 export { BearerToken, createHttpApiGateway, createPinoLogger, declareEmptyResourcesAndPrompts, newRequestId, wireToolsIntoMcpServer };
-//# sourceMappingURL=chunk-4MNLSWSZ.js.map
-//# sourceMappingURL=chunk-4MNLSWSZ.js.map
+//# sourceMappingURL=chunk-W7TPFRJB.js.map
+//# sourceMappingURL=chunk-W7TPFRJB.js.map