@affset/mcp 0.1.0 → 0.2.0

package/dist/tools/getCampaign.js

@@ -0,0 +1,150 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { formatInstant } from "../lib/time.js";
+import { mdCell, money, moneyPrecise } from "../lib/format.js";
+import { fetchPayoutRules } from "../lib/payoutRules.js";
+import { fetchTargetingRules, fetchTargetingTypes, UNENFORCED_TYPES } from "../lib/targeting.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+export const GET_CAMPAIGN_DESCRIPTION = "Get one campaign's full record: every field (including the untruncated offer URL, " +
+    "exact schedule, budgets/pacing, silent-conversions flag, payout goal type) plus its " +
+    "targeting rules and payout rules in one call. `list_campaigns` renders a summary table " +
+    "(offer URL truncated, no dates/pacing/silent) meant for scanning many campaigns; use " +
+    "this when you need one campaign's complete data — e.g. before recreating it as a new " +
+    "campaign, or before editing it with `update_campaign`.";
+export const getCampaignInputSchema = {
+    campaign_id: z
+        .union([
+        z
+            .string()
+            .trim()
+            .regex(/^[1-9]\d*$/, "campaign_id must be a positive integer")
+            .refine((value) => Number.isSafeInteger(Number(value)), "campaign_id is too large"),
+        z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    ])
+        .describe("Campaign id to fetch."),
+};
+export async function getCampaign(client, args) {
+    try {
+        const campaignId = String(args.campaign_id).trim();
+        if (!campaignId)
+            return textError("campaign_id is required.");
+        let campaign;
+        try {
+            campaign = await client.get(`/api/campaigns/${encodeURIComponent(campaignId)}`);
+        }
+        catch (err) {
+            if (err instanceof AffsetApiError && err.status === 404) {
+                return textError(`Campaign \`${campaignId}\` not found in this namespace.`);
+            }
+            throw err;
+        }
+        const [targetingRules, payoutRules, targetingTypes, timeZone] = await Promise.all([
+            fetchTargetingRules(client, campaignId),
+            fetchPayoutRules(client, campaignId),
+            // Names are a nicety; the rule table still works with bare type ids.
+            fetchTargetingTypes(client).catch(() => []),
+            client.getTenantTimezone(),
+        ]);
+        const typeById = new Map(targetingTypes.map((t) => [t.id, t]));
+        const fmt = (ms) => ms == null ? "—" : `${formatInstant(ms, timeZone)} ${mdCell(timeZone)} (${ms} epoch ms)`;
+        const deadTargetingRules = targetingRules.filter((rule) => {
+            const name = typeById.get(rule.targeting_rule_type_id)?.name.toLowerCase();
+            return name !== undefined && UNENFORCED_TYPES[name] !== undefined;
+        });
+        const payoutGoal = campaign.payout_goal_type?.trim();
+        const fields = [
+            "| Field | Value |",
+            "|---|---|",
+            `| Id | ${campaign.id} |`,
+            `| Name | ${mdCell(campaign.name)} |`,
+            `| Status | ${mdCell(campaign.status)} |`,
+            `| Advertiser | ${mdCell(campaign.user_email ?? "—")} |`,
+            `| Offer URL | ${mdCell(campaign.redirect_url ?? "—")} |`,
+            `| Model | ${mdCell(campaign.payment_model ?? "—")} |`,
+            `| Rate | ${campaign.rate != null ? moneyPrecise(campaign.rate) : "—"} |`,
+            `| Start date | ${fmt(campaign.start_date)} |`,
+            `| End date | ${fmt(campaign.end_date)} |`,
+            `| Daily budget | ${money(campaign.daily_budget)} |`,
+            `| Total budget | ${money(campaign.total_budget)} |`,
+            `| Pacing | ${mdCell(campaign.pacing ?? "—")} |`,
+            `| Budget paused | ${formatBudgetPaused(campaign)} |`,
+            `| Silent conversions | ${formatFlag(campaign.silent)} |`,
+            `| Payout goal type | ${payoutGoal ? mdCell(payoutGoal) : "_none — every conversion type gets the resolved payout_"} |`,
+            `| Created | ${fmt(campaign.created_at)} |`,
+            `| Updated | ${fmt(campaign.updated_at)} |`,
+        ];
+        return textResult([
+            `**Campaign** \`${campaign.id}\` — ${mdCell(campaign.name)}`,
+            "",
+            fields.join("\n"),
+            "",
+            `**Targeting rules** (${targetingRules.length})`,
+            "",
+            renderTargetingRules(targetingRules, typeById),
+            ...(deadTargetingRules.length
+                ? ["", ...renderDeadTargetingWarnings(deadTargetingRules, typeById)]
+                : []),
+            "",
+            `**Payout rules** (${payoutRules.length})`,
+            "",
+            renderPayoutRules(payoutRules),
+            "",
+            "_Recreate elsewhere with `create_campaign` + `update_campaign`, then " +
+                "`set_targeting_rule` / `set_payout_rule` for each rule above._",
+            "_Manage this campaign with `update_campaign`, `set_campaign_status`, " +
+                "`set_targeting_rule`, `set_payout_rule`, `set_payout_goal`._",
+        ].join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+function formatFlag(value) {
+    if (value == null)
+        return "—";
+    return value ? "yes" : "no";
+}
+function formatBudgetPaused(campaign) {
+    if (campaign.budget_paused == null)
+        return "—";
+    if (!campaign.budget_paused)
+        return "no";
+    const reason = campaign.budget_pause_reason?.trim();
+    return reason ? `yes (${mdCell(reason)})` : "yes (reason unavailable)";
+}
+function renderTargetingRules(rules, typeById) {
+    if (rules.length === 0) {
+        return "_No targeting rules — campaign is unrestricted on /serve._";
+    }
+    const lines = ["| Id | Type | Method | Rule |", "|---|---|---|---|"];
+    for (const r of rules) {
+        const t = typeById.get(r.targeting_rule_type_id);
+        const typeLabel = t
+            ? `${mdCell(t.name)} (${r.targeting_rule_type_id})`
+            : String(r.targeting_rule_type_id);
+        const inert = t && UNENFORCED_TYPES[t.name.toLowerCase()] ? " ⚠️" : "";
+        lines.push(`| ${r.id ?? "—"} | ${typeLabel}${inert} | ${mdCell(r.targeting_method)} | ${mdCell(r.rule)} |`);
+    }
+    return lines.join("\n");
+}
+function renderDeadTargetingWarnings(rules, typeById) {
+    const names = [...new Set(rules.map((rule) => typeById.get(rule.targeting_rule_type_id).name))];
+    return names.map((name) => `⚠️ \`${mdCell(name)}\` — ${UNENFORCED_TYPES[name.toLowerCase()]}. This rule has no effect.`);
+}
+function renderPayoutRules(rules) {
+    if (rules.length === 0) {
+        return "_No payout rules — conversions resolve to $0 until you set one._";
+    }
+    const lines = ["| Scope | Zone | Payout | Rule id |", "|---|---|--:|---|"];
+    for (const r of rules) {
+        const scope = r.zone_id == null ? "global" : "zone";
+        const zone = r.zone_id == null ? "—" : `\`${r.zone_id}\``;
+        lines.push(`| ${scope} | ${zone} | ${moneyPrecise(r.payout)} | \`${r.id}\` |`);
+    }
+    if (!rules.some((rule) => rule.zone_id == null)) {
+        lines.push("");
+        lines.push("_⚠️ No global rule — conversions from any zone without an override resolve to **$0**._");
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=getCampaign.js.map

package/dist/tools/getStats.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+import { RANGE_PRESETS } from "../lib/time.js";
+import { type GroupBy } from "../types.js";
+export declare const GET_STATS_DESCRIPTION: string;
+export declare const getStatsInputSchema: {
+    group_by: z.ZodDefault<z.ZodEnum<["date", "campaign_id", "zone_id", "country", "conversion_type", "publisher_email", "advertiser_email", "sub1", "sub2", "sub3", "sub4", "sub5"]>>;
+    range: z.ZodOptional<z.ZodEnum<["today", "yesterday", "last_7_days", "last_30_days", "this_month"]>>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    campaign_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    zone_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    sub1: z.ZodOptional<z.ZodString>;
+    sub2: z.ZodOptional<z.ZodString>;
+    sub3: z.ZodOptional<z.ZodString>;
+    sub4: z.ZodOptional<z.ZodString>;
+    sub5: z.ZodOptional<z.ZodString>;
+    conversion_type: z.ZodOptional<z.ZodString>;
+    advertiser_email: z.ZodOptional<z.ZodString>;
+    publisher_email: z.ZodOptional<z.ZodString>;
+};
+type GetStatsArgs = {
+    group_by: GroupBy;
+    range?: (typeof RANGE_PRESETS)[number];
+    from?: string;
+    to?: string;
+    campaign_ids?: string[];
+    zone_ids?: string[];
+    sub1?: string;
+    sub2?: string;
+    sub3?: string;
+    sub4?: string;
+    sub5?: string;
+    conversion_type?: string;
+    advertiser_email?: string;
+    publisher_email?: string;
+};
+export declare function getStats(client: AffsetClient, args: GetStatsArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/getStats.js

@@ -6,10 +6,18 @@ import { GROUP_BY_VALUES, SUB_KEYS } from "../types.js";
 export const GET_STATS_DESCRIPTION = "Pull affset traffic stats grouped by a single dimension. Returns impressions, clicks, " +
     "conversions, CR, payout, media cost and ROI as a table. Drill down by calling " +
     "repeatedly: first group_by=date or campaign_id, then narrow with filters " +
-    "(campaign_ids, zone_ids, sub1..sub5) and change group_by (zone_id, sub1, ...). " +
+    "(campaign_ids, zone_ids, sub1..sub5, conversion_type, advertiser_email, publisher_email) " +
+    "and change group_by (zone_id, sub1, ...). " +
     'Sub columns are titled with the tenant\'s configured labels (e.g. "Zone (sub1)") ' +
     "when set; group_by/filters always take the raw subN key. " +
-    "ROI is blank until traffic cost has been imported for the slice.";
+    "conversion_type only matches conversion rows, so filtering by it zeroes impressions, clicks " +
+    "and media cost — it narrows to conversions of that type, not clicks that led to one. " +
+    "ROI is blank until traffic cost has been imported for the slice. " +
+    "group_by=advertiser_email / publisher_email break down by team member; the API limits them " +
+    "to owner/manager plus the matching side's manager role (403 otherwise). " +
+    "advertiser_email / publisher_email are also standalone filters — narrow every row to one " +
+    "advertiser's campaigns or one publisher's zones regardless of group_by, instead of breaking " +
+    "every user out into its own row. Same role limits as the matching group_by value.";
 export const getStatsInputSchema = {
     group_by: z
         .enum(GROUP_BY_VALUES)
@@ -34,6 +42,25 @@ export const getStatsInputSchema = {
     sub3: z.string().optional().describe("Filter by sub3 value(s)."),
     sub4: z.string().optional().describe("Filter by sub4 value(s)."),
     sub5: z.string().optional().describe("Filter by sub5 value(s)."),
+    conversion_type: z
+        .string()
+        .optional()
+        .describe("Filter by conversion type value(s) (e.g. deposit, register), comma-separated for multiple. " +
+        'Pass "" to select conversions recorded without a type.'),
+    advertiser_email: z
+        .string()
+        .trim()
+        .email()
+        .optional()
+        .describe("Narrow to one advertiser's campaigns, independent of group_by. Owner/manager: any advertiser. " +
+        "advertiser_manager: only one of their own assigned advertisers (else 403). Other roles: 403."),
+    publisher_email: z
+        .string()
+        .trim()
+        .email()
+        .optional()
+        .describe("Narrow to one publisher's zones, independent of group_by. Owner/manager: any publisher. " +
+        "publisher_manager: only one of their own assigned publishers (else 403). Other roles: 403."),
 };
 export async function getStats(client, args) {
     try {
@@ -53,6 +80,14 @@ export async function getStats(client, args) {
             if (value !== undefined)
                 query[key] = value;
         }
+        if (args.conversion_type !== undefined)
+            query.conversion_type = args.conversion_type;
+        if (args.advertiser_email !== undefined) {
+            query.advertiser_email = args.advertiser_email.trim();
+        }
+        if (args.publisher_email !== undefined) {
+            query.publisher_email = args.publisher_email.trim();
+        }
         const data = await client.get("/api/stats", query);
         const table = formatStatsTable(data.stats ?? [], args.group_by, data.sub_labels);
         const heading = groupHeader(args.group_by, data.sub_labels);

package/dist/tools/getTrackingLink.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+import type { Config } from "../runtimeConfig.js";
+import { type LinkArgs } from "../lib/linkArgs.js";
+export declare const GET_TRACKING_LINK_DESCRIPTION: string;
+export declare const getTrackingLinkInputSchema: {
+    source_click_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    cost: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    sub1: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    sub2: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    sub3: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    sub4: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    sub5: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    campaign_id: z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodNumber]>;
+    zone_id: z.ZodOptional<z.ZodString>;
+};
+type GetTrackingLinkArgs = LinkArgs & {
+    campaign_id: string | number;
+    zone_id?: string;
+};
+export declare function getTrackingLink(client: AffsetClient, config: Config, args: GetTrackingLinkArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/getZoneUrl.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+import type { Config } from "../runtimeConfig.js";
+import { type LinkArgs } from "../lib/linkArgs.js";
+export declare const GET_ZONE_URL_DESCRIPTION: string;
+export declare const getZoneUrlInputSchema: {
+    source_click_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    cost: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    sub1: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    sub2: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    sub3: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    sub4: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    sub5: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    zone_id: z.ZodOptional<z.ZodString>;
+};
+type GetZoneUrlArgs = LinkArgs & {
+    zone_id?: string;
+};
+export declare function getZoneUrl(client: AffsetClient, config: Config, args: GetZoneUrlArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/listCampaigns.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+import { CAMPAIGN_STATUSES } from "../types.js";
+export declare const LIST_CAMPAIGNS_DESCRIPTION: string;
+export declare const listCampaignsInputSchema: {
+    status: z.ZodOptional<z.ZodEnum<["active", "paused", "archived"]>>;
+    name_contains: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    sort: z.ZodDefault<z.ZodEnum<["name", "created_at", "start_date"]>>;
+    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+};
+type ListCampaignsArgs = {
+    status?: (typeof CAMPAIGN_STATUSES)[number];
+    name_contains?: string;
+    limit: number;
+    offset: number;
+    sort: "name" | "created_at" | "start_date";
+    order: "asc" | "desc";
+};
+export declare function listCampaigns(client: AffsetClient, args: ListCampaignsArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/listConversions.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+declare const SORT_FIELDS: readonly ["created_at", "ad_event_id", "click_id"];
+export declare const LIST_CONVERSIONS_DESCRIPTION: string;
+export declare const listConversionsInputSchema: {
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    sort: z.ZodDefault<z.ZodEnum<["created_at", "ad_event_id", "click_id"]>>;
+    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+    click_id: z.ZodOptional<z.ZodString>;
+    source_click_id: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    payload_contains: z.ZodOptional<z.ZodString>;
+    zero_payout: z.ZodOptional<z.ZodBoolean>;
+};
+type ListConversionsArgs = {
+    limit: number;
+    offset: number;
+    sort: (typeof SORT_FIELDS)[number];
+    order: "asc" | "desc";
+    click_id?: string;
+    source_click_id?: string;
+    type?: string;
+    payload_contains?: string;
+    zero_payout?: boolean;
+};
+export declare function listConversions(client: AffsetClient, args: ListConversionsArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/listPayoutRules.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+export declare const LIST_PAYOUT_RULES_DESCRIPTION: string;
+export declare const listPayoutRulesInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+};
+type ListPayoutRulesArgs = {
+    campaign_id: string | number;
+};
+export declare function listPayoutRules(client: AffsetClient, args: ListPayoutRulesArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/listSubLabels.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+export declare const LIST_SUB_LABELS_DESCRIPTION: string;
+export declare const listSubLabelsInputSchema: {};
+export declare function listSubLabels(client: AffsetClient): Promise<CallToolResult>;

package/dist/tools/listTargetingRules.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+export declare const LIST_TARGETING_RULES_DESCRIPTION: string;
+export declare const listTargetingRulesInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+};
+type ListTargetingRulesArgs = {
+    campaign_id: string | number;
+};
+export declare function listTargetingRules(client: AffsetClient, args: ListTargetingRulesArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/listTargetingTypes.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+export declare const LIST_TARGETING_TYPES_DESCRIPTION: string;
+export declare const listTargetingTypesInputSchema: {};
+export declare function listTargetingTypes(client: AffsetClient): Promise<CallToolResult>;

package/dist/tools/listTeam.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+export declare const LIST_TEAM_DESCRIPTION: string;
+export declare const listTeamInputSchema: {
+    role: z.ZodOptional<z.ZodString>;
+    include_expired: z.ZodDefault<z.ZodBoolean>;
+};
+type ListTeamArgs = {
+    role?: string;
+    include_expired: boolean;
+};
+export declare function listTeam(client: AffsetClient, args: ListTeamArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/listZones.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+import { ZONE_STATUSES } from "../types.js";
+export declare const LIST_ZONES_DESCRIPTION: string;
+export declare const listZonesInputSchema: {
+    status: z.ZodOptional<z.ZodEnum<["active", "inactive"]>>;
+    name_contains: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    sort: z.ZodDefault<z.ZodEnum<["name", "created_at", "site_url"]>>;
+    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+};
+type ListZonesArgs = {
+    status?: (typeof ZONE_STATUSES)[number];
+    name_contains?: string;
+    limit: number;
+    offset: number;
+    sort: "name" | "created_at" | "site_url";
+    order: "asc" | "desc";
+};
+export declare function listZones(client: AffsetClient, args: ListZonesArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/removeTargetingRule.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+import { type TargetingMethod } from "../lib/targeting.js";
+export declare const REMOVE_TARGETING_RULE_DESCRIPTION: string;
+export declare const removeTargetingRuleInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    rule_id: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    method: z.ZodOptional<z.ZodEnum<["whitelist", "blacklist"]>>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type RemoveTargetingRuleArgs = {
+    campaign_id: string | number;
+    rule_id?: number;
+    type?: string | number;
+    method?: TargetingMethod;
+    confirm: boolean;
+};
+export declare function removeTargetingRule(client: AffsetClient, args: RemoveTargetingRuleArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/setCampaignStatus.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+/** Media-buyer verbs → API status. */
+export declare const CAMPAIGN_ACTIONS: readonly ["run", "pause"];
+export declare const SET_CAMPAIGN_STATUS_DESCRIPTION: string;
+export declare const setCampaignStatusInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    action: z.ZodEnum<["run", "pause"]>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type SetCampaignStatusArgs = {
+    campaign_id: string | number;
+    action: (typeof CAMPAIGN_ACTIONS)[number];
+    confirm: boolean;
+};
+export declare function setCampaignStatus(client: AffsetClient, args: SetCampaignStatusArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/setPayoutGoal.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+export declare const SET_PAYOUT_GOAL_DESCRIPTION: string;
+export declare const setPayoutGoalInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    goal_type: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type SetPayoutGoalArgs = {
+    campaign_id: string | number;
+    goal_type: string | null;
+    confirm: boolean;
+};
+export declare function setPayoutGoal(client: AffsetClient, args: SetPayoutGoalArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/setPayoutRule.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+export declare const SET_PAYOUT_RULE_DESCRIPTION: string;
+export declare const setPayoutRuleInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    payout: z.ZodNumber;
+    zone_id: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type SetPayoutRuleArgs = {
+    campaign_id: string | number;
+    payout: number;
+    zone_id?: string;
+    confirm: boolean;
+};
+export declare function setPayoutRule(client: AffsetClient, args: SetPayoutRuleArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/setSubLabels.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+export declare const SET_SUB_LABELS_DESCRIPTION: string;
+export declare const setSubLabelsInputSchema: {
+    sub1: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    sub2: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    sub3: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    sub4: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    sub5: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type SetSubLabelsArgs = {
+    sub1?: string | null;
+    sub2?: string | null;
+    sub3?: string | null;
+    sub4?: string | null;
+    sub5?: string | null;
+    confirm: boolean;
+};
+export declare function setSubLabels(client: AffsetClient, args: SetSubLabelsArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/setTargetingRule.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+import { type TargetingMethod } from "../lib/targeting.js";
+export declare const SET_TARGETING_RULE_DESCRIPTION: string;
+export declare const setTargetingRuleInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    type: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    method: z.ZodEnum<["whitelist", "blacklist"]>;
+    rule: z.ZodString;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type SetTargetingRuleArgs = {
+    campaign_id: string | number;
+    type: string | number;
+    method: TargetingMethod;
+    rule: string;
+    confirm: boolean;
+};
+export declare function setTargetingRule(client: AffsetClient, args: SetTargetingRuleArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/updateCampaign.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+import { CAMPAIGN_STATUSES, PACING_VALUES, PAYMENT_MODELS } from "../types.js";
+export declare const UPDATE_CAMPAIGN_DESCRIPTION: string;
+export declare const updateCampaignInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    name: z.ZodOptional<z.ZodString>;
+    redirect_url: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["active", "paused", "archived"]>>;
+    payment_model: z.ZodOptional<z.ZodEnum<["cpa", "cpm"]>>;
+    rate: z.ZodOptional<z.ZodNumber>;
+    start_date: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    end_date: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    daily_budget: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNull]>>;
+    total_budget: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNull]>>;
+    pacing: z.ZodOptional<z.ZodEnum<["asap", "even"]>>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type UpdateCampaignArgs = {
+    campaign_id: string | number;
+    name?: string;
+    redirect_url?: string;
+    status?: (typeof CAMPAIGN_STATUSES)[number];
+    payment_model?: (typeof PAYMENT_MODELS)[number];
+    rate?: number;
+    start_date?: string | number | null;
+    end_date?: string | number | null;
+    daily_budget?: number | null;
+    total_budget?: number | null;
+    pacing?: (typeof PACING_VALUES)[number];
+    confirm: boolean;
+};
+export declare function updateCampaign(client: AffsetClient, args: UpdateCampaignArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/updateZone.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+import { ZONE_STATUSES } from "../types.js";
+export declare const UPDATE_ZONE_DESCRIPTION: string;
+export declare const updateZoneInputSchema: {
+    zone_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["active", "inactive"]>>;
+    postback_url: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    site_url: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    traffic_back_url: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type UpdateZoneArgs = {
+    zone_id: string;
+    name?: string;
+    status?: (typeof ZONE_STATUSES)[number];
+    postback_url?: string | null;
+    site_url?: string | null;
+    traffic_back_url?: string | null;
+    confirm: boolean;
+};
+export declare function updateZone(client: AffsetClient, args: UpdateZoneArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/whoami.d.ts

@@ -0,0 +1,6 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+import type { Config } from "../runtimeConfig.js";
+export declare const WHOAMI_DESCRIPTION: string;
+export declare const whoamiInputSchema: {};
+export declare function whoami(client: AffsetClient, config: Config): Promise<CallToolResult>;