@oomol-lab/open-connector 1.9.1 → 1.9.2

package/src/providers/contextdev/input-schemas.js

@@ -0,0 +1,3082 @@
+import { s } from "../../core/json-schema.js";
+function parseRules(depth) {
+    const outputs = [
+        s.stringEnum("Output kind.", ["text", "html"]),
+        s.string("Attribute selector.", { pattern: "^@.*$" }),
+    ];
+    if (depth < 5)
+        outputs.push(parseRules(depth + 1));
+    return s.object("Named CSS extraction rules, including nested rules.", {}, {
+        additionalProperties: s.anyOf("CSS selector or extraction rule.", [
+            s.string("CSS selector, optionally followed by an attribute.", {
+                minLength: 1,
+                maxLength: 2048,
+            }),
+            s.object("Extraction rule.", {
+                selector: s.string("CSS selector to match within the current page or parent rule.", {
+                    minLength: 1,
+                    maxLength: 2048,
+                }),
+                type: s.stringEnum("Return the first match with `item` or all matches with `list`.", ["item", "list"]),
+                output: s.anyOf("Return text, HTML, an attribute such as `@href`, or nested field rules. Defaults to text.", outputs),
+            }, { required: ["selector"] }),
+        ]),
+        maxProperties: 100,
+    });
+}
+const scrapeParseRulesSchema = parseRules(1);
+const requestTagsSchema = s.array("Labels for filtering usage in the dashboard.", s.string("RequestTags item value.", { minLength: 1, maxLength: 50 }), { maxItems: 20 });
+const scrapeFormatsSchema = s.object("ScrapeFormats value.", {
+    html: s.boolean("Rendered HTML."),
+    markdown: s.boolean("Page content as Markdown."),
+    screenshot: s.boolean("A screenshot of the page."),
+    images: s.boolean("Images found on the page."),
+    bytes: s.boolean("The original HTTP response body."),
+    parse: s.boolean("Fields extracted with custom rules or a prebuilt parser, returned as `parsed`."),
+    highlights: s.boolean("Markdown excerpts relevant to `highlightsParams.query`."),
+    json: s.boolean("An object matching `jsonParams.schema`, extracted from the page."),
+    product: s.boolean("Product details such as name, price, and availability."),
+}, {
+    required: [],
+    not: {
+        allOf: [
+            { not: { required: ["html"], properties: { html: { const: true } } } },
+            { not: { required: ["markdown"], properties: { markdown: { const: true } } } },
+            { not: { required: ["screenshot"], properties: { screenshot: { const: true } } } },
+            { not: { required: ["images"], properties: { images: { const: true } } } },
+            { not: { required: ["bytes"], properties: { bytes: { const: true } } } },
+            { not: { required: ["parse"], properties: { parse: { const: true } } } },
+            { not: { required: ["highlights"], properties: { highlights: { const: true } } } },
+            { not: { required: ["json"], properties: { json: { const: true } } } },
+            { not: { required: ["product"], properties: { product: { const: true } } } },
+        ],
+    },
+});
+const scrapeMarkdownParamsSchema = s.object("ScrapeMarkdownParams value.", {
+    includeLinks: s.boolean("Keep link URLs in the Markdown (`html-conversion` only)."),
+    includeImages: s.boolean("Include images in the Markdown (`html-conversion` only)."),
+    inlineImages: s.stringEnum("How base64 images appear when `includeImages` is set (`html-conversion` only).", [
+        "placeholder",
+        "preserve",
+    ]),
+    sourcePreference: s.array("Markdown sources in order of preference: `html-conversion` converts the page HTML, `markdown-direct` uses Markdown the site publishes.", s.stringEnum("sourcePreference item value.", ["html-conversion", "markdown-direct"]), { minItems: 1, uniqueItems: true }),
+}, {
+    required: [],
+    allOf: [
+        {
+            if: { required: ["inlineImages"] },
+            then: { required: ["includeImages"], properties: { includeImages: { const: true } } },
+        },
+        {
+            if: {
+                required: ["sourcePreference"],
+                properties: { sourcePreference: { items: { not: { enum: ["html-conversion"] } } } },
+            },
+            then: {
+                properties: {
+                    includeLinks: { not: {} },
+                    includeImages: { not: {} },
+                    inlineImages: { not: {} },
+                },
+            },
+        },
+    ],
+});
+const scrapeScreenshotParamsSchema = s.object("ScrapeScreenshotParams value.", {
+    area: s.oneOf([
+        s.stringEnum("Page", ["viewport", "fullPage"]),
+        s.object("Element", {
+            selector: s.string("CSS selector matching exactly one visible element.", {
+                pattern: "\\S",
+                maxLength: 2048,
+            }),
+        }, { required: ["selector"] }),
+        s.object("Pixels from the document origin.", {
+            x: s.integer("Left edge of the capture, in pixels from the document origin.", {
+                minimum: 0,
+                maximum: 100000,
+            }),
+            y: s.integer("Top edge of the capture, in pixels from the document origin.", {
+                minimum: 0,
+                maximum: 100000,
+            }),
+            width: s.integer("Width of the capture in pixels.", { minimum: 1, maximum: 7680 }),
+            height: s.integer("Height of the capture in pixels.", { minimum: 1, maximum: 100000 }),
+        }, { required: ["x", "y", "width", "height"] }),
+    ], {
+        description: "What to capture: `viewport`, `fullPage`, one element, or a rectangle. Max 40 megapixels.",
+    }),
+    format: s.stringEnum("Image format for the screenshot.", ["png", "jpeg", "webp"]),
+}, { required: [] });
+const scrapeImageParamsSchema = s.object("ScrapeImageParams value.", {
+    enrich: s.array("Extra data per image: `dimensions`, `classification`, or a hosted `file` URL.", s.stringEnum("enrich item value.", ["dimensions", "classification", "file"]), { minItems: 1, maxItems: 3, uniqueItems: true }),
+    dedupe: s.stringEnum("Set `visual` to drop visual duplicates, keeping the largest copy.", ["none", "visual"]),
+}, { required: [] });
+const scrapeParseParamsSchema = s.oneOf([
+    s.object("Custom parser", {
+        type: s.literal("custom", {
+            description: "Extract fields using custom CSS rules. This is the default when type is omitted.",
+        }),
+        rules: scrapeParseRulesSchema,
+    }, { required: ["rules"] }),
+    s.object("Prebuilt parser", {
+        type: s.literal("prebuilt", {
+            description: "Use a prebuilt parser instead of custom rules.",
+        }),
+        parser: s.stringEnum("The prebuilt parser to use. See https://docs.context.dev/scrape/prebuilt-parsers for supported sources, request options, and output schemas.", [
+            "google-maps",
+            "google-maps-reviews",
+            "google-play",
+            "google-play-reviews",
+            "app-store",
+            "app-store-reviews",
+            "g2-reviews",
+            "instagram-profile",
+            "instagram-post",
+            "instagram-feed",
+            "tiktok-profile",
+            "tiktok-video",
+            "tiktok-feed",
+            "tiktok-comments",
+            "tiktok-followers",
+            "tiktok-following",
+            "tiktok-user-search",
+            "emails",
+            "phone-numbers",
+            "links",
+        ]),
+        sort: s.stringEnum("google-maps-reviews only. Order of data.reviews. newest, relevant, highest, and lowest follow Google; oldest returns the earliest reviews first, which Google itself does not offer.", ["newest", "oldest", "relevant", "highest", "lowest"]),
+        limit: s.integer("google-maps-reviews only. Maximum number of reviews to return. Defaults to 100; maximum 1000.", { minimum: 1, maximum: 1000 }),
+    }, { required: ["type", "parser"] }),
+], {
+    description: "ScrapeParseParams value.",
+});
+const scrapeHighlightsParamsSchema = s.object("ScrapeHighlightsParams value.", {
+    query: s.string("The question or topic to find passages for.", {
+        minLength: 1,
+        maxLength: 2000,
+    }),
+    maxCharacters: s.integer("Maximum combined length of returned passages.", {
+        minimum: 100,
+        maximum: 20000,
+    }),
+}, { required: ["query"] });
+const scrapeJsonParamsSchema = s.object("ScrapeJsonParams value.", {
+    schema: s.object("JSON Schema (not an example object) for a top-level object, up to 50 KB. Use optional or nullable fields for missing facts.", {}, { required: [], additionalProperties: true }),
+    instructions: s.string("Extra guidance, such as which facts to prefer or how to read a field.", {
+        maxLength: 2000,
+    }),
+}, { required: ["schema"] });
+const scrapeProductParamsSchema = s.object("ScrapeProductParams value.", {
+    dedupeImages: s.boolean("Drop visually duplicate product images, keeping the largest copy."),
+}, { required: [] });
+const scrapeProfileSchema = s.oneOf([
+    s.object("Existing Profile", {
+        type: s.literal("existing", {
+            description: "Reuse a saved browser profile.",
+        }),
+        profileId: s.string("The ID returned in profile.id by an earlier scrape.", {
+            pattern: "^prof_[a-f0-9]{32}$",
+        }),
+    }, { required: ["type", "profileId"] }),
+    s.object("New Profile", {
+        type: s.literal("new", {
+            description: "Sign in and create a browser profile.",
+        }),
+        identifier: s.string("Username or email for the target website.", {
+            minLength: 1,
+            maxLength: 1024,
+        }),
+        password: s.string("Password used to sign in. It is never stored in the profile.", {
+            minLength: 1,
+            maxLength: 4096,
+        }),
+        description: s.string("Optional label shown when listing profiles with `GET /org/browser/profiles`.", {
+            minLength: 1,
+            maxLength: 500,
+        }),
+    }, { required: ["type", "identifier", "password"] }),
+], {
+    description: "ScrapeProfile value.",
+});
+const scrapeActionSchema = s.oneOf([
+    s.object("Instruction", {
+        type: s.stringEnum("Use `perform` for a plain-language browser instruction.", ["perform"]),
+        action: s.string("One browser instruction, such as clicking a button or entering text.", {
+            minLength: 1,
+            maxLength: 500,
+        }),
+    }, { required: ["type", "action"] }),
+    s.object("Scroll", {
+        type: s.stringEnum("Use `scroll` to move through the page or a container.", ["scroll"]),
+        direction: s.stringEnum("Direction to scroll.", ["down", "up", "left", "right"]),
+        amount: s.oneOf([
+            s.integer("amount value.", { minimum: 1, maximum: 100000 }),
+            s.stringEnum("amount value.", ["viewport", "max"]),
+        ], {
+            description: "Distance per scroll: pixels, one `viewport`, or `max` to reach the end.",
+        }),
+        selector: s.string("Scroll this container. Omit to scroll the page.", {
+            pattern: "\\S",
+            maxLength: 2000,
+        }),
+        maxScrolls: s.integer("Maximum number of scroll steps for this action.", {
+            minimum: 1,
+            maximum: 50,
+        }),
+    }, { required: ["type"] }),
+    s.object("Wait", {
+        type: s.stringEnum("Use `wait` to pause for a fixed duration.", ["wait"]),
+        milliseconds: s.integer("Time to pause in milliseconds before the next action.", {
+            minimum: 0,
+            maximum: 30000,
+        }),
+    }, { required: ["type", "milliseconds"] }),
+    s.object("Wait for element", {
+        type: s.stringEnum("Use `waitFor` to wait for a matching element.", ["waitFor"]),
+        selector: s.string("CSS selector to wait for before continuing.", {
+            pattern: "\\S",
+            maxLength: 2048,
+        }),
+    }, { required: ["type", "selector"] }),
+], {
+    description: "Browser action",
+});
+const scrapePdfOptionsSchema = s.object("ScrapePdfOptions value.", {
+    startPage: s.integer("First page to parse, starting at 1.", { minimum: 1 }),
+    endPage: s.integer("Last page to parse. Must be at least `startPage`.", { minimum: 1 }),
+    ocr: s.stringEnum("Set `auto` to read scanned pages with OCR.", ["off", "auto"]),
+}, { required: [] });
+const scrapeSharedParamsSchema = s.object("ScrapeSharedParams value.", {
+    profile: s.describe(scrapeProfileSchema, "Create or reuse an authenticated browser profile. Requires a paid plan and an HTTPS target. Profiles persist session state, bypass shared caches, and cannot be combined with ZDR, custom headers, raw bytes, Google Maps, app store, Instagram, or G2 parsers. The emails, phone-numbers, and links parsers support profiles."),
+    country: s.string("Proxy country as a two-letter code, such as `US`. Case-insensitive.", {
+        pattern: "^[A-Za-z]{2}$",
+    }),
+    headers: s.object("HTTP headers to send to the target site. Requests with headers skip the cache.", {}, {
+        required: [],
+        additionalProperties: s.string("headers entry value.", {
+            maxLength: 8192,
+            pattern: "^[^\\r\\n]*$",
+        }),
+        propertyNames: {
+            pattern: "^[!#$%&'*+.^_`|~0-9A-Za-z-]+$",
+            not: {
+                pattern: "^(?:[Hh][Oo][Ss][Tt]|[Cc][Oo][Nn][Tt][Ee][Nn][Tt]-[Ll][Ee][Nn][Gg][Tt][Hh]|[Cc][Oo][Nn][Nn][Ee][Cc][Tt][Ii][Oo][Nn]|[Kk][Ee][Ee][Pp]-[Aa][Ll][Ii][Vv][Ee]|[Pp][Rr][Oo][Xx][Yy]-[Aa][Uu][Tt][Hh][Ee][Nn][Tt][Ii][Cc][Aa][Tt][Ee]|[Pp][Rr][Oo][Xx][Yy]-[Aa][Uu][Tt][Hh][Oo][Rr][Ii][Zz][Aa][Tt][Ii][Oo][Nn]|[Pp][Rr][Oo][Xx][Yy]-[Cc][Oo][Nn][Nn][Ee][Cc][Tt][Ii][Oo][Nn]|[Tt][Ee]|[Tt][Rr][Aa][Ii][Ll][Ee][Rr]|[Tt][Rr][Aa][Nn][Ss][Ff][Ee][Rr]-[Ee][Nn][Cc][Oo][Dd][Ii][Nn][Gg]|[Uu][Pp][Gg][Rr][Aa][Dd][Ee]|[Ee][Xx][Pp][Ee][Cc][Tt])$",
+            },
+        },
+    }),
+    viewport: s.object("Browser size in pixels. Omit for 1920 × 1080. When provided, missing dimensions default to 1440 × 900.", {
+        width: s.integer("Browser viewport width in pixels.", { minimum: 240, maximum: 7680 }),
+        height: s.integer("Browser viewport height in pixels.", { minimum: 240, maximum: 4320 }),
+    }, { required: [] }),
+    theme: s.stringEnum("Emulate a light or dark color scheme.", ["light", "dark"]),
+    dismissCookies: s.boolean("Accept cookie banners before actions and capture."),
+    dismissPopups: s.boolean("Close other popups before actions and capture."),
+    actions: s.array("Browser steps run in order before capture. Requires a paid plan. Skips the cache.", scrapeActionSchema, { minItems: 1, maxItems: 5 }),
+    waitFor: s.oneOf([
+        s.integer("Milliseconds", { minimum: 0, maximum: 30000 }),
+        s.string("CSS selector", { pattern: "\\S", maxLength: 2048 }),
+    ], {
+        description: "Milliseconds, or a CSS selector to wait for, after actions. Defaults to 500 (2000 with frames or XML).",
+    }),
+    settleAnimations: s.boolean("Wait for CSS animations to finish before capture. Defaults to `true` when `screenshot` is requested."),
+    mainContentOnly: s.boolean("Keep only the main content. Doesn't affect `screenshot`, `bytes`, or `product`."),
+    includeSelectors: s.array("Keep only elements matching these CSS selectors.", s.string("includeSelectors item value.", { pattern: "\\S", maxLength: 2048 }), { minItems: 1, maxItems: 50, uniqueItems: true }),
+    excludeSelectors: s.array("Remove elements matching these CSS selectors. Overrides `includeSelectors`.", s.string("excludeSelectors item value.", { pattern: "\\S", maxLength: 2048 }), { minItems: 1, maxItems: 50, uniqueItems: true }),
+    includeFrames: s.boolean("Include iframe content in HTML and text outputs. Screenshots always show visible frames."),
+    parsers: s.object("Document parsing options.", {
+        pdf: s.describe(scrapePdfOptionsSchema, "PDF page range and OCR."),
+    }, { required: [] }),
+}, { required: [] });
+const scrapeTimeoutSchema = s.object("Request deadline and what to return when it passes.", {
+    milliseconds: s.integer("Deadline in milliseconds.", { minimum: 1, maximum: 300000 }),
+    behavior: s.stringEnum('"fail" returns 408 at the deadline. "return-partial" returns available results; inspect the response’s partial flag. "return-partial" requires at least 5000 ms.', ["fail", "return-partial"]),
+}, { required: ["milliseconds"] });
+const newsSearchByNaturalLanguageSchema = s.object("Search all news with a plain-language query. Returns up to 100 matches, ordered by relevance.", {
+    type: s.stringEnum("Use `natural_language` to search all news with a plain-language query.", ["natural_language"]),
+    query: s.string('What to search for, in plain language, such as "chip export restrictions to China".', {
+        minLength: 2,
+        maxLength: 1000,
+    }),
+}, { required: ["type", "query"] });
+const newsSearchEntityByNameSchema = s.object("Identify the company by name.", {
+    type: s.stringEnum("Use `name` to identify the company by name.", ["name"]),
+    name: s.string("Company name.", { minLength: 2, maxLength: 200 }),
+}, { required: ["type", "name"] });
+const newsSearchEntityByDomainSchema = s.object("Identify the company by website domain.", {
+    type: s.stringEnum("Use `domain` to identify the company by website domain.", ["domain"]),
+    domain: s.string("Company website domain, such as apple.com.", {
+        minLength: 1,
+        maxLength: 253,
+    }),
+}, { required: ["type", "domain"] });
+const newsSearchEntityByTickerSchema = s.object("Identify the company by stock ticker, optionally scoped to an exchange.", {
+    type: s.stringEnum("Use `ticker` to identify a publicly traded company.", ["ticker"]),
+    ticker: s.string("Public-company ticker.", {
+        minLength: 1,
+        maxLength: 20,
+        pattern: "^[A-Za-z0-9.-]+$",
+    }),
+    exchange: s.stringEnum("Stock exchange the ticker trades on, used to disambiguate tickers listed on multiple exchanges.", [
+        "AMEX",
+        "AMS",
+        "AQS",
+        "ASX",
+        "ATH",
+        "BER",
+        "BME",
+        "BRU",
+        "BSE",
+        "BUD",
+        "BUE",
+        "BVC",
+        "CBOE",
+        "CNQ",
+        "CPH",
+        "DFM",
+        "DOH",
+        "DUB",
+        "DUS",
+        "DXE",
+        "EGX",
+        "FSX",
+        "HAM",
+        "HEL",
+        "HKSE",
+        "HOSE",
+        "ICE",
+        "IOB",
+        "IST",
+        "JKT",
+        "JNB",
+        "JPX",
+        "KLS",
+        "KOE",
+        "KSC",
+        "KUW",
+        "LIS",
+        "LSE",
+        "MCX",
+        "MEX",
+        "MIL",
+        "MUN",
+        "NASDAQ",
+        "NEO",
+        "NSE",
+        "NYSE",
+        "NZE",
+        "OSL",
+        "OTC",
+        "PAR",
+        "PNK",
+        "PRA",
+        "RIS",
+        "SAO",
+        "SAU",
+        "SES",
+        "SET",
+        "SGO",
+        "SHH",
+        "SHZ",
+        "SIX",
+        "STO",
+        "STU",
+        "TAI",
+        "TAL",
+        "TLV",
+        "TSX",
+        "TSXV",
+        "TWO",
+        "VIE",
+        "WSE",
+        "XETRA",
+    ]),
+}, { required: ["type", "ticker"] });
+const newsSearchEntityByIsinSchema = s.object("Identify the company by International Securities Identification Number.", {
+    type: s.stringEnum("Use `isin` to identify the company by its securities identifier.", ["isin"]),
+    isin: s.string("International Securities Identification Number.", {
+        pattern: "^[A-Za-z]{2}[A-Za-z0-9]{9}[0-9]$",
+    }),
+}, { required: ["type", "isin"] });
+const newsSearchByEntitySchema = s.object("Find news about a specific company.", {
+    type: s.stringEnum("Use `entity` to find news about a specific company.", ["entity"]),
+    entity: s.oneOf([
+        newsSearchEntityByNameSchema,
+        newsSearchEntityByDomainSchema,
+        newsSearchEntityByTickerSchema,
+        newsSearchEntityByIsinSchema,
+    ], {
+        description: "The company to search news for, identified by name, domain, ticker, or ISIN.",
+    }),
+}, { required: ["type", "entity"] });
+const partialTimeoutSchema = s.object("Request deadline and what to return when it passes.", {
+    milliseconds: s.integer("Deadline in milliseconds.", { minimum: 1000, maximum: 300000 }),
+    behavior: s.stringEnum('"fail" returns 408 at the deadline. "return-partial" returns available results; inspect the response’s partial flag.', ["fail", "return-partial"]),
+}, { required: ["milliseconds"] });
+const lenientPartialTimeoutSchema = s.object("Request deadline and what to return when it passes.", {
+    milliseconds: s.integer("Deadline in milliseconds.", { minimum: 1, maximum: 300000 }),
+    behavior: s.stringEnum('"fail" returns 408 at the deadline. "return-partial" returns available results; inspect the response’s partial flag.', ["fail", "return-partial"]),
+}, { required: ["milliseconds"] });
+const browserCountryCodeSchema = s.stringEnum("Fetch from this country (ISO 3166-1 alpha-2).", [
+    "ad",
+    "ae",
+    "af",
+    "ag",
+    "ai",
+    "al",
+    "am",
+    "ao",
+    "ar",
+    "at",
+    "au",
+    "aw",
+    "az",
+    "ba",
+    "bb",
+    "bd",
+    "be",
+    "bf",
+    "bg",
+    "bh",
+    "bi",
+    "bj",
+    "bm",
+    "bn",
+    "bo",
+    "bq",
+    "br",
+    "bs",
+    "bw",
+    "by",
+    "bz",
+    "ca",
+    "cd",
+    "cf",
+    "cg",
+    "ch",
+    "ci",
+    "cl",
+    "cm",
+    "cn",
+    "co",
+    "cr",
+    "cv",
+    "cw",
+    "cy",
+    "cz",
+    "de",
+    "dj",
+    "dk",
+    "dm",
+    "do",
+    "dz",
+    "ec",
+    "ee",
+    "eg",
+    "es",
+    "et",
+    "fi",
+    "fj",
+    "fr",
+    "ga",
+    "gb",
+    "gd",
+    "ge",
+    "gf",
+    "gg",
+    "gh",
+    "gm",
+    "gn",
+    "gp",
+    "gq",
+    "gr",
+    "gt",
+    "gu",
+    "gw",
+    "gy",
+    "hk",
+    "hn",
+    "hr",
+    "ht",
+    "hu",
+    "id",
+    "ie",
+    "il",
+    "im",
+    "in",
+    "iq",
+    "ir",
+    "is",
+    "it",
+    "je",
+    "jm",
+    "jo",
+    "jp",
+    "ke",
+    "kg",
+    "kh",
+    "kn",
+    "kr",
+    "kw",
+    "ky",
+    "kz",
+    "la",
+    "lb",
+    "lc",
+    "lk",
+    "lr",
+    "ls",
+    "lt",
+    "lu",
+    "lv",
+    "ly",
+    "ma",
+    "mc",
+    "md",
+    "me",
+    "mf",
+    "mg",
+    "mk",
+    "ml",
+    "mm",
+    "mn",
+    "mo",
+    "mq",
+    "mr",
+    "mt",
+    "mu",
+    "mv",
+    "mw",
+    "mx",
+    "my",
+    "mz",
+    "na",
+    "nc",
+    "ne",
+    "ng",
+    "ni",
+    "nl",
+    "no",
+    "np",
+    "nz",
+    "om",
+    "pa",
+    "pe",
+    "pf",
+    "pg",
+    "ph",
+    "pk",
+    "pl",
+    "pr",
+    "ps",
+    "pt",
+    "py",
+    "qa",
+    "re",
+    "ro",
+    "rs",
+    "ru",
+    "rw",
+    "sa",
+    "sc",
+    "sd",
+    "se",
+    "sg",
+    "si",
+    "sk",
+    "sl",
+    "sm",
+    "sn",
+    "so",
+    "sr",
+    "ss",
+    "st",
+    "sv",
+    "sx",
+    "sy",
+    "sz",
+    "tc",
+    "td",
+    "tg",
+    "th",
+    "tj",
+    "tl",
+    "tm",
+    "tn",
+    "tr",
+    "tt",
+    "tw",
+    "tz",
+    "ua",
+    "ug",
+    "us",
+    "uy",
+    "uz",
+    "vc",
+    "ve",
+    "vg",
+    "vi",
+    "vn",
+    "ye",
+    "yt",
+    "za",
+    "zm",
+    "zw",
+]);
+const webScrapeWaitActionSchema = s.object("Pause for a fixed number of milliseconds before continuing to the next action.", {
+    do: s.stringEnum("Use `wait` to pause for a fixed duration.", ["wait"]),
+    timeMs: s.integer("Time to pause in milliseconds before the next action.", {
+        minimum: 0,
+        maximum: 30000,
+    }),
+}, { required: ["do", "timeMs"] });
+const webScrapePerformActionSchema = s.object("Resolve and perform one natural-language browser action.", {
+    do: s.stringEnum("Use `perform` for a plain-language browser instruction.", ["perform"]),
+    action: s.string("One browser instruction, such as clicking a button or entering text.", {
+        minLength: 1,
+        maxLength: 500,
+    }),
+}, { required: ["do", "action"] });
+const webScrapeScrollActionSchema = s.object("Scroll the page or a selected scrollable container, waiting adaptively for content and dimensions to settle after each iteration.", {
+    do: s.stringEnum("Use `scroll` to move through the page or a container.", ["scroll"]),
+    direction: s.stringEnum("Direction to scroll. Defaults to down.", ["up", "down", "left", "right"]),
+    amount: s.anyOf("Pixels per scroll, one visible viewport, or the current scroll boundary. Defaults to viewport.", [
+        s.integer("amount value.", { minimum: 1, maximum: 100000 }),
+        s.stringEnum("amount value.", ["viewport", "max"]),
+    ]),
+    container: s.string("CSS selector for the first matching scroll container. Defaults to the page.", {
+        minLength: 1,
+        maxLength: 2000,
+    }),
+    maxScrolls: s.integer("Maximum scroll iterations. Stops early when scrolling and scrollable extent stop changing. Defaults to 1.", { minimum: 1, maximum: 50 }),
+}, { required: ["do"] });
+const webScrapeActionSchema = s.oneOf([webScrapeWaitActionSchema, webScrapePerformActionSchema, webScrapeScrollActionSchema], {
+    description: "Browser action discriminated by `do`. Each variant exposes only its applicable fields.",
+});
+const supportedLanguageSchema = s.stringEnum("Language, e.g. `english`.", [
+    "afrikaans",
+    "albanian",
+    "amharic",
+    "arabic",
+    "armenian",
+    "assamese",
+    "aymara",
+    "azeri",
+    "basque",
+    "belarusian",
+    "bengali",
+    "bosnian",
+    "bulgarian",
+    "burmese",
+    "cantonese",
+    "catalan",
+    "cebuano",
+    "chinese",
+    "corsican",
+    "croatian",
+    "czech",
+    "danish",
+    "dutch",
+    "english",
+    "esperanto",
+    "estonian",
+    "farsi",
+    "fijian",
+    "finnish",
+    "french",
+    "galician",
+    "georgian",
+    "german",
+    "greek",
+    "guarani",
+    "gujarati",
+    "haitian-creole",
+    "hausa",
+    "hawaiian",
+    "hebrew",
+    "hindi",
+    "hmong",
+    "hungarian",
+    "icelandic",
+    "igbo",
+    "indonesian",
+    "irish",
+    "italian",
+    "japanese",
+    "javanese",
+    "kannada",
+    "kazakh",
+    "khmer",
+    "kinyarwanda",
+    "korean",
+    "kurdish",
+    "kyrgyz",
+    "lao",
+    "latin",
+    "latvian",
+    "lingala",
+    "lithuanian",
+    "luxembourgish",
+    "macedonian",
+    "malagasy",
+    "malay",
+    "malayalam",
+    "maltese",
+    "maori",
+    "marathi",
+    "mongolian",
+    "nepali",
+    "norwegian",
+    "odia",
+    "oromo",
+    "pashto",
+    "pidgin",
+    "polish",
+    "portuguese",
+    "punjabi",
+    "quechua",
+    "romanian",
+    "russian",
+    "samoan",
+    "scottish-gaelic",
+    "serbian",
+    "sesotho",
+    "shona",
+    "sindhi",
+    "sinhala",
+    "slovak",
+    "slovene",
+    "somali",
+    "spanish",
+    "sundanese",
+    "swahili",
+    "swedish",
+    "tagalog",
+    "tajik",
+    "tamil",
+    "tatar",
+    "telugu",
+    "thai",
+    "tibetan",
+    "tigrinya",
+    "tongan",
+    "tswana",
+    "turkish",
+    "turkmen",
+    "ukrainian",
+    "urdu",
+    "uyghur",
+    "uzbek",
+    "vietnamese",
+    "welsh",
+    "wolof",
+    "xhosa",
+    "yiddish",
+    "yoruba",
+    "zulu",
+]);
+const brandRetrieveByDomainRequestSchema = s.object("Retrieve brand data by domain. Cannot be combined with name, email, or ticker.", {
+    force_language: {
+        allOf: [supportedLanguageSchema, s.nullable(s.string("force language value."))],
+        description: "force language value.",
+    },
+    maxSpeed: s.boolean("Optional parameter to optimize the API call for maximum speed. When set to true, the API will skip time-consuming operations for faster response at the cost of less comprehensive data."),
+    maxAgeMs: s.integer("Maximum age of cached brand data in ms. Defaults to 3 months; clamped to 0–1 year. `0` refreshes."),
+    timeoutOpts: partialTimeoutSchema,
+    type: s.stringEnum("Discriminator for domain-based brand retrieval.", ["by_domain"]),
+    domain: s.string("Domain name to retrieve brand data for (e.g., 'stripe.com').", {
+        minLength: 3,
+    }),
+    tags: requestTagsSchema,
+}, { required: ["type", "domain"] });
+const countryGLSchema = s.stringEnum("Two-letter ISO 3166-1 alpha-2 country code (GL parameter) used to localize search.", [
+    "af",
+    "al",
+    "dz",
+    "as",
+    "ad",
+    "ao",
+    "ai",
+    "aq",
+    "ag",
+    "ar",
+    "am",
+    "aw",
+    "au",
+    "at",
+    "az",
+    "bs",
+    "bh",
+    "bd",
+    "bb",
+    "by",
+    "be",
+    "bz",
+    "bj",
+    "bm",
+    "bt",
+    "bo",
+    "ba",
+    "bw",
+    "bv",
+    "br",
+    "io",
+    "bn",
+    "bg",
+    "bf",
+    "bi",
+    "kh",
+    "cm",
+    "ca",
+    "cv",
+    "ky",
+    "cf",
+    "td",
+    "cl",
+    "cn",
+    "cx",
+    "cc",
+    "co",
+    "km",
+    "cg",
+    "cd",
+    "ck",
+    "cr",
+    "ci",
+    "hr",
+    "cu",
+    "cy",
+    "cz",
+    "dk",
+    "dj",
+    "dm",
+    "do",
+    "ec",
+    "eg",
+    "sv",
+    "gq",
+    "er",
+    "ee",
+    "et",
+    "fk",
+    "fo",
+    "fj",
+    "fi",
+    "fr",
+    "gf",
+    "pf",
+    "tf",
+    "ga",
+    "gm",
+    "ge",
+    "de",
+    "gh",
+    "gi",
+    "gr",
+    "gl",
+    "gd",
+    "gp",
+    "gu",
+    "gt",
+    "gn",
+    "gw",
+    "gy",
+    "ht",
+    "hm",
+    "va",
+    "hn",
+    "hk",
+    "hu",
+    "is",
+    "in",
+    "id",
+    "ir",
+    "iq",
+    "ie",
+    "il",
+    "it",
+    "jm",
+    "jp",
+    "jo",
+    "kz",
+    "ke",
+    "ki",
+    "kp",
+    "kr",
+    "kw",
+    "kg",
+    "la",
+    "lv",
+    "lb",
+    "ls",
+    "lr",
+    "ly",
+    "li",
+    "lt",
+    "lu",
+    "mo",
+    "mk",
+    "mg",
+    "mw",
+    "my",
+    "mv",
+    "ml",
+    "mt",
+    "mh",
+    "mq",
+    "mr",
+    "mu",
+    "yt",
+    "mx",
+    "fm",
+    "md",
+    "mc",
+    "mn",
+    "ms",
+    "ma",
+    "mz",
+    "mm",
+    "na",
+    "nr",
+    "np",
+    "nl",
+    "an",
+    "nc",
+    "nz",
+    "ni",
+    "ne",
+    "ng",
+    "nu",
+    "nf",
+    "mp",
+    "no",
+    "om",
+    "pk",
+    "pw",
+    "ps",
+    "pa",
+    "pg",
+    "py",
+    "pe",
+    "ph",
+    "pn",
+    "pl",
+    "pt",
+    "pr",
+    "qa",
+    "re",
+    "ro",
+    "ru",
+    "rw",
+    "sh",
+    "kn",
+    "lc",
+    "pm",
+    "vc",
+    "ws",
+    "sm",
+    "st",
+    "sa",
+    "sn",
+    "rs",
+    "sc",
+    "sl",
+    "sg",
+    "sk",
+    "si",
+    "sb",
+    "so",
+    "za",
+    "gs",
+    "es",
+    "lk",
+    "sd",
+    "sr",
+    "sj",
+    "sz",
+    "se",
+    "ch",
+    "sy",
+    "tw",
+    "tj",
+    "tz",
+    "th",
+    "tl",
+    "tg",
+    "tk",
+    "to",
+    "tt",
+    "tn",
+    "tr",
+    "tm",
+    "tc",
+    "tv",
+    "ug",
+    "ua",
+    "ae",
+    "gb",
+    "us",
+    "um",
+    "uy",
+    "uz",
+    "vu",
+    "ve",
+    "vn",
+    "vg",
+    "vi",
+    "wf",
+    "eh",
+    "ye",
+    "zm",
+    "zw",
+]);
+const brandRetrieveByNameRequestSchema = s.object("Retrieve brand data by company name. Cannot be combined with domain, email, or ticker.", {
+    force_language: {
+        allOf: [supportedLanguageSchema, s.nullable(s.string("force language value."))],
+        description: "force language value.",
+    },
+    maxSpeed: s.boolean("Optional parameter to optimize the API call for maximum speed. When set to true, the API will skip time-consuming operations for faster response at the cost of less comprehensive data."),
+    maxAgeMs: s.integer("Maximum age of cached brand data in ms. Defaults to 3 months; clamped to 0–1 year. `0` refreshes."),
+    timeoutOpts: partialTimeoutSchema,
+    type: s.stringEnum("Discriminator for name-based brand retrieval.", ["by_name"]),
+    name: s.string("Company name to retrieve brand data for (e.g., 'Apple Inc').", {
+        minLength: 3,
+        maxLength: 30,
+    }),
+    country_gl: {
+        allOf: [
+            countryGLSchema,
+            s.unknown("Optional country code hint (GL parameter) to specify the country when looking up by company name."),
+        ],
+        description: "country gl value.",
+    },
+    tags: requestTagsSchema,
+}, { required: ["type", "name"] });
+const brandRetrieveByEmailRequestSchema = s.object("Retrieve brand data by email address. The domain is extracted from the email. Free and disposable email providers are rejected with 422. Cannot be combined with domain, name, or ticker.", {
+    force_language: {
+        allOf: [supportedLanguageSchema, s.nullable(s.string("force language value."))],
+        description: "force language value.",
+    },
+    maxSpeed: s.boolean("Optional parameter to optimize the API call for maximum speed. When set to true, the API will skip time-consuming operations for faster response at the cost of less comprehensive data."),
+    maxAgeMs: s.integer("Maximum age of cached brand data in ms. Defaults to 3 months; clamped to 0–1 year. `0` refreshes."),
+    timeoutOpts: partialTimeoutSchema,
+    type: s.stringEnum("Discriminator for email-based brand retrieval.", ["by_email"]),
+    email: s.string("Email address to retrieve brand data for (e.g., 'jane@stripe.com').", {
+        minLength: 1,
+        format: "email",
+    }),
+    tags: requestTagsSchema,
+}, { required: ["type", "email"] });
+const stockExchangeSchema = s.stringEnum("Stock exchange code.", [
+    "AMEX",
+    "AMS",
+    "AQS",
+    "ASX",
+    "ATH",
+    "BER",
+    "BME",
+    "BRU",
+    "BSE",
+    "BUD",
+    "BUE",
+    "BVC",
+    "CBOE",
+    "CNQ",
+    "CPH",
+    "DFM",
+    "DOH",
+    "DUB",
+    "DUS",
+    "DXE",
+    "EGX",
+    "FSX",
+    "HAM",
+    "HEL",
+    "HKSE",
+    "HOSE",
+    "ICE",
+    "IOB",
+    "IST",
+    "JKT",
+    "JNB",
+    "JPX",
+    "KLS",
+    "KOE",
+    "KSC",
+    "KUW",
+    "LIS",
+    "LSE",
+    "MCX",
+    "MEX",
+    "MIL",
+    "MUN",
+    "NASDAQ",
+    "NEO",
+    "NSE",
+    "NYSE",
+    "NZE",
+    "OSL",
+    "OTC",
+    "PAR",
+    "PNK",
+    "PRA",
+    "RIS",
+    "SAO",
+    "SAU",
+    "SES",
+    "SET",
+    "SGO",
+    "SHH",
+    "SHZ",
+    "SIX",
+    "STO",
+    "STU",
+    "TAI",
+    "TAL",
+    "TLV",
+    "TSX",
+    "TSXV",
+    "TWO",
+    "VIE",
+    "WSE",
+    "XETRA",
+]);
+const brandRetrieveByTickerRequestSchema = s.object("Retrieve brand data by stock ticker. Cannot be combined with domain, name, or email.", {
+    force_language: {
+        allOf: [supportedLanguageSchema, s.nullable(s.string("force language value."))],
+        description: "force language value.",
+    },
+    maxSpeed: s.boolean("Optional parameter to optimize the API call for maximum speed. When set to true, the API will skip time-consuming operations for faster response at the cost of less comprehensive data."),
+    maxAgeMs: s.integer("Maximum age of cached brand data in ms. Defaults to 3 months; clamped to 0–1 year. `0` refreshes."),
+    timeoutOpts: partialTimeoutSchema,
+    type: s.stringEnum("Discriminator for ticker-based brand retrieval.", ["by_ticker"]),
+    ticker: s.string("Stock ticker symbol to retrieve brand data for (e.g., 'AAPL').", {
+        minLength: 1,
+        maxLength: 15,
+        pattern: "^[A-Za-z0-9.]+$",
+    }),
+    ticker_exchange: {
+        allOf: [
+            stockExchangeSchema,
+            s.unknown("Optional stock exchange for the ticker. Defaults to NASDAQ if not specified."),
+        ],
+        description: "ticker exchange value.",
+    },
+    tags: requestTagsSchema,
+}, { required: ["type", "ticker"] });
+const brandRetrieveByDirectUrlRequestSchema = s.object("Retrieve brand data from this exact URL. Cross-site enrichment and other lookup identifiers are excluded.", {
+    type: s.stringEnum("Discriminator for direct-URL-based brand retrieval.", ["by_direct_url"]),
+    direct_url: s.string("Full http(s) URL to fetch brand data from (e.g., 'https://stripe.com/enterprise'). Only this URL is fetched — not the entire internet.", { format: "uri" }),
+    timeoutOpts: partialTimeoutSchema,
+    tags: requestTagsSchema,
+}, { required: ["type", "direct_url"] });
+const brandRetrieveFromTransactionRequestSchema = s.object("Identify brand data from a transaction descriptor. Cannot be combined with domain, name, email, or ticker.", {
+    type: s.stringEnum("Discriminator for transaction-based brand retrieval.", ["by_transaction"]),
+    transaction_info: s.string("Transaction information to identify the brand.", {
+        minLength: 3,
+        maxLength: 500,
+    }),
+    force_language: {
+        allOf: [supportedLanguageSchema, s.nullable(s.string("force language value."))],
+        description: "force language value.",
+    },
+    maxSpeed: s.boolean("Optional parameter to optimize the API call for maximum speed. When set to true, the API will skip time-consuming operations for faster response at the cost of less comprehensive data."),
+    timeoutOpts: partialTimeoutSchema,
+    country_gl: {
+        allOf: [
+            countryGLSchema,
+            s.unknown("Optional country code hint (GL parameter) to specify the country when identifying a transaction."),
+        ],
+        description: "country gl value.",
+    },
+    city: s.string("Optional city name to prioritize when searching for the brand."),
+    mcc: s.anyOf("Optional Merchant Category Code (MCC) to help identify the business category or industry.", [
+        s.string("mcc value."),
+        s.number("mcc value."),
+    ]),
+    phone: s.anyOf("Optional phone number from the transaction to help verify brand match.", [
+        s.string("phone value."),
+        s.number("phone value."),
+    ]),
+    high_confidence_only: s.boolean("When set to true, the API performs additional verification to ensure the identified brand matches the transaction with high confidence."),
+    tags: requestTagsSchema,
+}, { required: ["type", "transaction_info"] });
+const utilityPrefetchDomainIdentifierSchema = s.object("Prefetch by domain.", {
+    domain: s.string("Domain, e.g. `stripe.com`.", { minLength: 3 }),
+}, { required: ["domain"] });
+const utilityPrefetchEmailIdentifierSchema = s.object("Prefetch by email. The domain will be extracted and validated.", {
+    email: s.string("Email address to prefetch data for. The domain will be extracted from the email. Free email providers (gmail.com, yahoo.com, etc.) and disposable email addresses are not allowed.", { minLength: 1, format: "email" }),
+}, { required: ["email"] });
+const utilityPrefetchIdentifierSchema = s.oneOf([utilityPrefetchDomainIdentifierSchema, utilityPrefetchEmailIdentifierSchema], {
+    description: "Identifier of the target to prefetch. Provide exactly one of domain or email.",
+});
+const timeoutSchema = s.object("Request deadline and what to return when it passes.", {
+    milliseconds: s.integer("Deadline in milliseconds.", { minimum: 1000, maximum: 300000 }),
+    behavior: s.stringEnum('Only "fail" is supported: return 408 at the deadline.', ["fail"]),
+}, { required: ["milliseconds"] });
+const monitorsModeSchema = s.stringEnum("Always `web`. Optional.", ["web"]);
+const monitorsPageTargetSchema = s.object("Watch a single web page. Exact detection reports visible-text diffs; semantic detection judges confirmed stable diffs against `instructions`.", {
+    type: s.stringEnum("Use `page` to watch one web page.", ["page"]),
+    url: s.string("Public HTTP(S) page URL to monitor.", { format: "uri" }),
+    instructions: s.string("Plain-language goal describing which page changes matter. When provided without change_detection, semantic detection is inferred.", { minLength: 1, maxLength: 2000 }),
+    normalize_whitespace: s.boolean("Normalize whitespace before comparing or analyzing text."),
+    include_selectors: s.array("Monitor these CSS-selected regions. Empty or omitted uses main content. Changes create a new baseline.", s.string("include selectors item value.", { minLength: 1, maxLength: 2048 }), { maxItems: 50 }),
+    exclude_selectors: s.array("Remove matching regions after inclusions. Changes create a new baseline.", s.string("exclude selectors item value.", { minLength: 1, maxLength: 2048 }), { maxItems: 50 }),
+    actions: s.nullable(s.array("Optional browser actions executed in array order after the page loads, before content is captured, on every run. Requires a paid plan. Maximum: 5 actions. Changes create a new baseline.", webScrapeActionSchema, { maxItems: 5 })),
+}, { required: ["type", "url"] });
+const monitorsSitemapTargetSchema = s.object("Watch a site’s URL inventory for confirmed additions and removals.", {
+    type: s.stringEnum("Use `sitemap` to watch a site for added or removed URLs.", ["sitemap"]),
+    url: s.string("Sitemap URL to monitor.", { format: "uri" }),
+    include: s.array("URL path patterns to include (max 50).", s.string("include item value.", { minLength: 1, maxLength: 200 }), { maxItems: 50 }),
+    exclude: s.array("URL path patterns to exclude (max 50).", s.string("exclude item value.", { minLength: 1, maxLength: 200 }), { maxItems: 50 }),
+    max_urls: s.integer("Maximum number of sitemap URLs to track (capped at 10,000).", {
+        minimum: 1,
+        maximum: 10000,
+    }),
+}, { required: ["type", "url"] });
+const monitorsExtractTargetSchema = s.object("Extract target", {
+    type: s.stringEnum("Use `extract` to watch structured data across selected pages.", ["extract"]),
+    url: s.string("Root URL to extract structured data from.", { format: "uri" }),
+    schema: s.object("JSON Schema for page selection and the baseline snapshot. Changes return diffs and evidence.", {}, { required: [], additionalProperties: s.unknown("schema entry value.") }),
+    instructions: s.string("Natural-language instructions guiding which pages and facts to track and which changes to report.", { minLength: 1, maxLength: 2000 }),
+    max_pages: s.integer("Maximum number of pages to track.", { minimum: 1, maximum: 50 }),
+    max_depth: s.integer("Optional maximum link depth from the starting URL (0 = only the starting page).", {
+        minimum: 0,
+        maximum: 10,
+    }),
+    follow_subdomains: s.boolean("Allow page discovery on subdomains of the target site."),
+}, { required: ["type", "url", "instructions"] });
+const monitorsTargetSchema = s.oneOf([
+    monitorsPageTargetSchema,
+    monitorsSitemapTargetSchema,
+    {
+        allOf: [
+            monitorsExtractTargetSchema,
+            s.unknown("Track relevant pages selected by `schema` and `instructions`; refresh the page set periodically."),
+        ],
+        description: "MonitorsTarget value.",
+    },
+], {
+    description: "What to watch: a page, a sitemap, or data extracted from a site.",
+});
+const monitorsExactChangeDetectionSchema = s.object("Detect exact changes. For page targets, this means visible text diffs. For sitemap targets, this means URL additions and removals.", {
+    type: s.stringEnum("Use `exact` to compare visible text or sitemap URLs.", ["exact"]),
+}, { required: ["type"] });
+const monitorsSemanticChangeDetectionSchema = s.object("Detect meaningful content changes using the target’s instructions and optional schema.", {
+    type: s.stringEnum("Use `semantic` to judge changes against the target instructions.", ["semantic"]),
+    confidence_threshold: s.number("Minimum confidence required to report a meaningful change, from 0 to 1.", {
+        minimum: 0,
+        maximum: 1,
+    }),
+}, { required: ["type"] });
+const monitorsChangeDetectionSchema = s.oneOf([monitorsExactChangeDetectionSchema, monitorsSemanticChangeDetectionSchema], {
+    description: "How changes are judged. Defaults to `semantic` for extract targets and page targets with `instructions`, otherwise `exact`.",
+});
+const monitorsScheduleUnitSchema = s.stringEnum("Time unit used with `frequency` to set the run interval.", [
+    "minutes",
+    "hours",
+    "days",
+]);
+const monitorsIntervalScheduleSchema = s.object("Run the monitor on a fixed interval defined by a frequency and a unit, e.g. every 6 hours or every 2 days. The total interval (frequency × unit) must be between 10 minutes and 1 year.", {
+    type: s.stringEnum("Use `interval` to run on a repeating schedule.", ["interval"]),
+    frequency: s.integer("Number of units between runs. The resulting interval (frequency × unit) must be at least 10 minutes and at most 1 year (e.g. minimum 10 when unit is minutes; maximum 365 when unit is days).", { minimum: 1, maximum: 525600 }),
+    unit: monitorsScheduleUnitSchema,
+}, { required: ["type", "frequency", "unit"] });
+const monitorsScheduleSchema = s.oneOf([monitorsIntervalScheduleSchema], {
+    description: "How often the monitor runs. Defaults to once a day.",
+});
+const webhookRetrySchema = s.object("Webhook retry settings. Use {} for the default schedule.", {
+    delays_seconds: s.array("Retry delays in seconds, totaling at most 72 hours. Use [] to disable automatic retries.", s.integer("delays seconds item value.", { minimum: 1, maximum: 86400 }), { maxItems: 10 }),
+}, { required: [] });
+const monitorsWebhookConfigSchema = s.object("MonitorsWebhookConfig value.", {
+    url: s.string("Public HTTP(S) URL that receives events. Slack and GovSlack URLs get formatted messages.", {
+        format: "uri",
+    }),
+    events: s.array("Events to deliver. Defaults to `change.detected`; `run.completed` also includes unchanged runs.", s.stringEnum("events item value.", ["change.detected", "run.completed"]), { minItems: 1, maxItems: 2, uniqueItems: true }),
+    retry: webhookRetrySchema,
+}, { required: ["url"] });
+const monitorsNullableWebhookConfigSchema = s.anyOf("Webhook destination and delivery settings. Null means no webhook is configured.", [
+    {
+        allOf: [monitorsWebhookConfigSchema],
+        description: "MonitorsNullableWebhookConfig value.",
+    },
+    s.literal(null, {
+        description: "MonitorsNullableWebhookConfig value.",
+    }),
+]);
+const monitorsRunStatusSchema = s.stringEnum("Lifecycle status of a run. `skipped` runs never executed — see `skip_reason` (insufficient credits, monitor paused, or superseded by a concurrent run).", ["queued", "running", "completed", "failed", "skipped"]);
+const batchUnifiedScrapeDataSchema = s.object("Use the same formats and parameters as POST /web/scrape, replacing url with urls. Options apply to every page.", {
+    urls: s.array("Pages to scrape. Maximum 100000.", s.object("A page to scrape, with optional data for matching results.", {
+        url: s.string("Page URL to scrape.", { minLength: 1 }),
+        itemId: s.string("Your ID for this page, returned with its result. The same URL can use different IDs.", {
+            minLength: 1,
+            maxLength: 200,
+        }),
+        meta: s.object("Custom JSON returned unchanged with this page result.", {}, { required: [], additionalProperties: s.unknown("meta entry value.") }),
+    }, { required: ["url"] }), { minItems: 1, maxItems: 100000 }),
+    formats: s.describe(scrapeFormatsSchema, "Outputs to return. Set at least one to `true`."),
+    markdownParams: s.describe(scrapeMarkdownParamsSchema, "Markdown options. Requires `formats.markdown`."),
+    screenshotParams: s.describe(scrapeScreenshotParamsSchema, "Screenshot options. Requires formats.screenshot: true."),
+    imageParams: s.describe(scrapeImageParamsSchema, "Image options. Requires formats.images: true."),
+    parseParams: s.describe(scrapeParseParamsSchema, "Requires `formats.parse: true`; required when it is set."),
+    highlightsParams: s.describe(scrapeHighlightsParamsSchema, "Requires `formats.highlights: true`; required when it is set."),
+    jsonParams: s.describe(scrapeJsonParamsSchema, "Requires `formats.json: true`; required when it is set."),
+    productParams: s.describe(scrapeProductParamsSchema, "Product options. Requires formats.product: true."),
+    sharedParams: s.describe(scrapeSharedParamsSchema, "Browser and content settings shared by all outputs."),
+    maxAgeMs: s.integer("Maximum age of a cached output, in milliseconds. `0` fetches fresh. Defaults to 3 days (259200000 ms). Maximum: 1 year (31536000000 ms).", { minimum: 0, maximum: 31536000000 }),
+    zdr: s.stringEnum("Batches persist their results. Only disabled is supported; enabled returns ZDR_NOT_SUPPORTED.", [
+        "disabled",
+    ]),
+    timeoutOpts: s.describe(scrapeTimeoutSchema, "Deadline for each page, using the same behavior and defaults as POST /web/scrape."),
+    tags: s.describe(requestTagsSchema, "Labels for tracking request usage. Not retained when zdr is enabled."),
+}, { required: ["urls", "formats"] });
+const batchUnifiedCrawlDataSchema = s.object("Use the same formats and parameters as POST /web/scrape, replacing url with source. Options apply to every page.", {
+    source: s.oneOf([
+        s.object("Discover pages by following links from one URL.", {
+            type: s.stringEnum("Start from one page.", ["start_url"]),
+            url: s.string("Page where crawling begins. A URL without a scheme is read as https://.", {
+                minLength: 1,
+            }),
+            controls: s.object("Limits and filters for page discovery.", {
+                maxUrls: s.integer("Maximum pages to fetch. Unused reserved credits are refunded. Maximum 100000.", {
+                    minimum: 1,
+                    maximum: 100000,
+                }),
+                maxDepth: s.integer("Maximum link depth. Source pages are depth 0. No limit when omitted.", {
+                    minimum: 0,
+                    maximum: 50,
+                }),
+                followSubdomains: s.boolean("Follow links to subdomains."),
+                regex: s.string("Regex pattern for URLs to include. The `start_url` itself is always included.", {
+                    maxLength: 256,
+                }),
+                excludeRegex: s.string("Regex pattern for URLs to exclude, even when they match `regex`. The `start_url` itself is always included.", { maxLength: 256 }),
+                languages: s.anyOf("Only follow pages in these languages, or `same_as_start_url`; all languages when omitted.", [
+                    s.stringEnum("languages value.", ["same_as_start_url"]),
+                    s.array("languages value.", s.stringEnum("languages item value.", [
+                        "am",
+                        "ar",
+                        "az",
+                        "be",
+                        "bg",
+                        "bn",
+                        "ca",
+                        "ceb",
+                        "cs",
+                        "cy",
+                        "da",
+                        "de",
+                        "el",
+                        "en",
+                        "es",
+                        "et",
+                        "eu",
+                        "fa",
+                        "fi",
+                        "fr",
+                        "gu",
+                        "ha",
+                        "haw",
+                        "he",
+                        "hi",
+                        "hr",
+                        "hu",
+                        "hy",
+                        "id",
+                        "is",
+                        "it",
+                        "ja",
+                        "ka",
+                        "kk",
+                        "kn",
+                        "ko",
+                        "ku",
+                        "ky",
+                        "lo",
+                        "lt",
+                        "lv",
+                        "mk",
+                        "ml",
+                        "mn",
+                        "mr",
+                        "ms",
+                        "ne",
+                        "nl",
+                        "no",
+                        "or",
+                        "pa",
+                        "pl",
+                        "ps",
+                        "pt",
+                        "ro",
+                        "ru",
+                        "sk",
+                        "sl",
+                        "so",
+                        "sq",
+                        "sr",
+                        "sv",
+                        "sw",
+                        "ta",
+                        "te",
+                        "th",
+                        "tl",
+                        "tr",
+                        "uk",
+                        "ur",
+                        "uz",
+                        "vi",
+                        "yo",
+                        "zh",
+                    ]), { minItems: 1 }),
+                ]),
+            }, { required: [] }),
+        }, { required: ["type", "url"] }),
+        s.object("Scrape the pages listed in a domain's sitemap. Links on those pages are not followed.", {
+            type: s.stringEnum("Scrape the URLs in the domain's sitemap.", ["sitemap"]),
+            domain: s.string("Domain whose sitemap lists the pages to scrape. A full URL is reduced to its domain.", {
+                minLength: 3,
+            }),
+            controls: s.object("Limits and filters for the sitemap URLs. A sitemap batch scrapes exactly those URLs and never follows links off them, so there is no crawl depth here.", {
+                maxUrls: s.integer("Maximum pages to fetch. Unused reserved credits are refunded. Maximum 100000.", {
+                    minimum: 1,
+                    maximum: 100000,
+                }),
+                regex: s.string("Regex pattern; only sitemap URLs matching it are scraped.", {
+                    maxLength: 256,
+                }),
+                excludeRegex: s.string("Regex pattern; sitemap URLs matching it are not scraped, even when they match `regex`.", { maxLength: 256 }),
+            }, { required: [] }),
+        }, { required: ["type", "domain"] }),
+    ], {
+        description: "How to find pages to crawl.",
+    }),
+    formats: s.describe(scrapeFormatsSchema, "Outputs to return. Set at least one to `true`."),
+    markdownParams: s.describe(scrapeMarkdownParamsSchema, "Markdown options. Requires `formats.markdown`."),
+    screenshotParams: s.describe(scrapeScreenshotParamsSchema, "Screenshot options. Requires formats.screenshot: true."),
+    imageParams: s.describe(scrapeImageParamsSchema, "Image options. Requires formats.images: true."),
+    parseParams: s.describe(scrapeParseParamsSchema, "Requires `formats.parse: true`; required when it is set."),
+    highlightsParams: s.describe(scrapeHighlightsParamsSchema, "Requires `formats.highlights: true`; required when it is set."),
+    jsonParams: s.describe(scrapeJsonParamsSchema, "Requires `formats.json: true`; required when it is set."),
+    productParams: s.describe(scrapeProductParamsSchema, "Product options. Requires formats.product: true."),
+    sharedParams: s.describe(scrapeSharedParamsSchema, "Browser and content settings shared by all outputs."),
+    maxAgeMs: s.integer("Maximum age of a cached output, in milliseconds. `0` fetches fresh. Defaults to 3 days (259200000 ms). Maximum: 1 year (31536000000 ms).", { minimum: 0, maximum: 31536000000 }),
+    zdr: s.stringEnum("Batches persist their results. Only disabled is supported; enabled returns ZDR_NOT_SUPPORTED.", [
+        "disabled",
+    ]),
+    timeoutOpts: s.describe(scrapeTimeoutSchema, "Deadline for each page, using the same behavior and defaults as POST /web/scrape."),
+    tags: s.describe(requestTagsSchema, "Labels for tracking request usage. Not retained when zdr is enabled."),
+}, { required: ["source", "formats"] });
+const companySearchFiltersSchema = s.object("Additional constraints every result must match.", {
+    countries: s.array("Headquarters countries as two-letter codes, such as US or GB.", s.string("countries item value.", { pattern: "^[A-Z]{2}$" }), {}),
+    employees_min: s.integer("Minimum headcount; includes overlapping employee ranges.", {
+        minimum: 0,
+    }),
+    employees_max: s.integer("Maximum headcount; includes overlapping employee ranges.", {
+        minimum: 0,
+    }),
+}, { required: [] });
+export const submit_feedbackInputSchema = s.object("Submit agent feedback input.", {
+    request_id: s.string("The request_id of the API call the feedback is about, from its response body or X-Request-Id header.", { format: "uuid" }),
+    category: s.stringEnum("Kind of issue.", [
+        "bug",
+        "docs_mismatch",
+        "friction",
+        "feature_gap",
+        "quality_degradation",
+        "other",
+    ]),
+    note: s.string("What went wrong and what you expected instead.", {
+        minLength: 1,
+        maxLength: 4000,
+    }),
+    url: s.string("The page the feedback is about, such as one page of a crawl or a docs page.", {
+        maxLength: 2048,
+        format: "uri",
+    }),
+    tags: requestTagsSchema,
+}, { required: ["category", "note"] });
+export const list_logsInputSchema = s.object("List request logs input.", {
+    from: s.string("Only include requests at or after this ISO 8601 timestamp. Defaults to 24 hours before `to`.", {
+        format: "date-time",
+    }),
+    to: s.string("Only include requests at or before this ISO 8601 timestamp. Defaults to now.", {
+        format: "date-time",
+    }),
+    path: s.string("Filter by endpoint path, with or without the /v1 prefix.", {
+        minLength: 1,
+        maxLength: 200,
+        pattern: "^\\/",
+    }),
+    key_id: s.string("Filter by the API key that made the request.", {
+        minLength: 1,
+        maxLength: 200,
+    }),
+    status_code: s.integer("Filter by exact HTTP status code.", { minimum: 100, maximum: 599 }),
+    error_code: s.string("Filter by the `error_code` returned in the response.", {
+        pattern: "^[A-Z][A-Z0-9_]{1,63}$",
+    }),
+    errors_only: s.boolean("Only include requests that returned a 4xx or 5xx status."),
+    tags: s.string("Comma-separated request tags. Matches requests carrying any of them. Up to 20 tags, each 1-50 characters."),
+    search: s.string("Case-insensitive substring match against the request query and body, e.g. a domain.", {
+        minLength: 1,
+        maxLength: 200,
+    }),
+    page: s.integer("Page number, starting at 1.", { minimum: 1, maximum: 1000 }),
+    limit: s.integer("Number of log entries per page.", { minimum: 1, maximum: 100 }),
+}, { required: [] });
+export const get_logInputSchema = s.object("Retrieve a request log input.", {
+    request_id: s.string("The request ID of the logged API call.", { format: "uuid" }),
+}, { required: ["request_id"] });
+export const list_profilesInputSchema = s.object("List browser profiles input.", {
+    limit: s.integer("Number of profiles per page.", { minimum: 1, maximum: 100 }),
+    cursor: s.string("The `next_cursor` from the previous page.", {
+        pattern: "^prof_[a-f0-9]{32}$",
+    }),
+}, { required: [] });
+export const get_usageInputSchema = s.object("Retrieve credit usage input.", {}, { required: [], additionalProperties: true });
+export const get_usage_historyInputSchema = s.object("Retrieve usage history input.", {
+    from: s.string("Start of the range, as an ISO 8601 timestamp. Defaults to 24 hours before `to` for `hour`, 30 days for `day`, and 366 days for `month`.", { format: "date-time" }),
+    to: s.string("End of the range, as an ISO 8601 timestamp. Defaults to now.", {
+        format: "date-time",
+    }),
+    interval: s.stringEnum("Bucket size. `hour` covers up to 7 days; `day` and `month` cover up to 366 days. Buckets start on UTC boundaries.", ["hour", "day", "month"]),
+    group_by: s.stringEnum("Split each bucket by endpoint path, API key, or HTTP status code.", [
+        "path",
+        "key_id",
+        "status_code",
+    ]),
+}, { required: [] });
+export const list_webhook_deliveriesInputSchema = s.oneOf([
+    s.object("By Batch", {
+        type: s.stringEnum("Delivery source.", ["batch"]),
+        batch_id: s.string("Filter by batch ID.", {
+            minLength: 1,
+            maxLength: 200,
+            pattern: "^[\\w-]+$",
+        }),
+        status: s.stringEnum("Filter by delivery status.", [
+            "pending",
+            "delivering",
+            "retrying",
+            "delivered",
+            "failed",
+            "cancelled",
+        ]),
+        created_after: s.string("Only include events created after this ISO 8601 timestamp.", {
+            format: "date-time",
+        }),
+        limit: s.integer("Number of deliveries to return.", { minimum: 1, maximum: 100 }),
+        cursor: s.string("The next_cursor from the previous response.", {
+            pattern: "^whd_[a-f0-9]{32}$",
+        }),
+        tags: requestTagsSchema,
+    }, { required: ["type"] }),
+    s.object("By Monitor", {
+        type: s.stringEnum("Delivery source.", ["monitor"]),
+        monitor_id: s.string("Filter by monitor ID.", {
+            minLength: 1,
+            maxLength: 200,
+            pattern: "^[\\w-]+$",
+        }),
+        run_id: s.string("Filter by monitor run ID.", {
+            minLength: 1,
+            maxLength: 200,
+            pattern: "^[\\w-]+$",
+        }),
+        status: s.stringEnum("Filter by delivery status.", [
+            "pending",
+            "delivering",
+            "retrying",
+            "delivered",
+            "failed",
+            "cancelled",
+        ]),
+        created_after: s.string("Only include events created after this ISO 8601 timestamp.", {
+            format: "date-time",
+        }),
+        limit: s.integer("Number of deliveries to return.", { minimum: 1, maximum: 100 }),
+        cursor: s.string("The next_cursor from the previous response.", {
+            pattern: "^whd_[a-f0-9]{32}$",
+        }),
+        tags: requestTagsSchema,
+    }, { required: ["type"] }),
+], {
+    description: "List webhook deliveries input.",
+});
+export const get_webhook_deliveryInputSchema = s.object("Retrieve a webhook delivery input.", {
+    delivery_id: s.string("Delivery ID.", { pattern: "^whd_[a-f0-9]{32}$" }),
+    tags: s.describe(requestTagsSchema, "Comma-separated labels for filtering usage, e.g. `production,team-alpha`."),
+}, { required: ["delivery_id"] });
+export const list_webhook_delivery_attemptsInputSchema = s.object("List webhook delivery attempts input.", {
+    delivery_id: s.string("Delivery ID.", { pattern: "^whd_[a-f0-9]{32}$" }),
+    limit: s.integer("Number of attempts to return.", { minimum: 1, maximum: 100 }),
+    cursor: s.string("The next_cursor from the previous response.", {
+        pattern: "^wha_[a-f0-9]{32}$",
+    }),
+    tags: s.describe(requestTagsSchema, "Comma-separated labels for filtering usage, e.g. `production,team-alpha`."),
+}, { required: ["delivery_id"] });
+export const retry_webhook_deliveryInputSchema = s.object("Retry a webhook delivery input.", {
+    force: s.boolean("Resend even if the delivery already succeeded. Defaults to false."),
+    tags: requestTagsSchema,
+    delivery_id: s.string("Delivery ID.", { pattern: "^whd_[a-f0-9]{32}$" }),
+    idempotencyKey: s.string("Unique key to prevent duplicate retry requests.", { maxLength: 200 }),
+}, { required: ["delivery_id"] });
+export const scrape_webInputSchema = s.object("Scrape Anything input.", {
+    url: s.string("Public HTTP or HTTPS URL to scrape.", { format: "uri", pattern: "^https?://" }),
+    formats: s.describe(scrapeFormatsSchema, "Outputs to return. Set at least one to `true`."),
+    markdownParams: s.describe(scrapeMarkdownParamsSchema, "Markdown options. Requires `formats.markdown`."),
+    screenshotParams: s.describe(scrapeScreenshotParamsSchema, "Screenshot options. Requires formats.screenshot: true."),
+    imageParams: s.describe(scrapeImageParamsSchema, "Image options. Requires formats.images: true."),
+    parseParams: s.describe(scrapeParseParamsSchema, "Requires `formats.parse: true`; required when it is set."),
+    highlightsParams: s.describe(scrapeHighlightsParamsSchema, "Requires `formats.highlights: true`; required when it is set."),
+    jsonParams: s.describe(scrapeJsonParamsSchema, "Requires `formats.json: true`; required when it is set."),
+    productParams: s.describe(scrapeProductParamsSchema, "Product options. Requires formats.product: true."),
+    sharedParams: s.describe(scrapeSharedParamsSchema, "Browser and content settings shared by all outputs."),
+    maxAgeMs: s.integer("Maximum age of a cached output, in milliseconds. `0` fetches fresh. Defaults to 3 days (259200000 ms). Maximum: 1 year (31536000000 ms).", { minimum: 0, maximum: 31536000000 }),
+    zdr: s.stringEnum("`enabled` turns on zero data retention. Your organization must have ZDR enabled.", [
+        "enabled",
+        "disabled",
+    ]),
+    timeoutOpts: s.describe(scrapeTimeoutSchema, "Deadline for the whole request. Defaults to 90000 ms with `fail`. Fixed waits must end before it."),
+    tags: s.describe(requestTagsSchema, "Labels for tracking request usage. Not retained when zdr is enabled."),
+}, {
+    required: ["url", "formats"],
+    allOf: [
+        {
+            if: { required: ["markdownParams"] },
+            then: {
+                properties: {
+                    formats: { required: ["markdown"], properties: { markdown: { const: true } } },
+                },
+            },
+        },
+        {
+            if: { required: ["screenshotParams"] },
+            then: {
+                properties: {
+                    formats: { required: ["screenshot"], properties: { screenshot: { const: true } } },
+                },
+            },
+        },
+        {
+            if: { required: ["imageParams"] },
+            then: {
+                properties: {
+                    formats: { required: ["images"], properties: { images: { const: true } } },
+                },
+            },
+        },
+        {
+            if: { required: ["parseParams"] },
+            then: {
+                properties: { formats: { required: ["parse"], properties: { parse: { const: true } } } },
+            },
+        },
+        {
+            if: {
+                properties: { formats: { required: ["parse"], properties: { parse: { const: true } } } },
+            },
+            then: { required: ["parseParams"] },
+        },
+        {
+            if: { required: ["highlightsParams"] },
+            then: {
+                properties: {
+                    formats: { required: ["highlights"], properties: { highlights: { const: true } } },
+                },
+            },
+        },
+        {
+            if: {
+                properties: {
+                    formats: { required: ["highlights"], properties: { highlights: { const: true } } },
+                },
+            },
+            then: { required: ["highlightsParams"] },
+        },
+        {
+            if: { required: ["jsonParams"] },
+            then: {
+                properties: { formats: { required: ["json"], properties: { json: { const: true } } } },
+            },
+        },
+        {
+            if: {
+                properties: { formats: { required: ["json"], properties: { json: { const: true } } } },
+            },
+            then: { required: ["jsonParams"] },
+        },
+        {
+            if: { required: ["productParams"] },
+            then: {
+                properties: {
+                    formats: { required: ["product"], properties: { product: { const: true } } },
+                },
+            },
+        },
+    ],
+});
+export const search_newsInputSchema = s.object("Search news input.", {
+    searchBy: s.oneOf([newsSearchByNaturalLanguageSchema, newsSearchByEntitySchema], {
+        description: "What to search for: a specific company, or a natural-language query across all news.",
+    }),
+    filterBy: s.object("Optional result filters. Use at most one of sourceDomain, sourceCountry, articleLanguage, or articleType. A date range may accompany that category; date.from must not exceed date.to.", {
+        sourceDomain: s.array("Publisher domains to include. Up to 3.", s.string("sourceDomain item value.", { minLength: 1, maxLength: 253 }), { minItems: 1, maxItems: 3 }),
+        sourceCountry: s.array("Publisher countries to include, as lowercase ISO 3166-1 alpha-2 codes. Up to 3.", s.stringEnum("sourceCountry item value.", [
+            "ae",
+            "ar",
+            "au",
+            "ca",
+            "cg",
+            "ch",
+            "cl",
+            "cz",
+            "de",
+            "fi",
+            "fr",
+            "gb",
+            "hk",
+            "il",
+            "in",
+            "jp",
+            "kr",
+            "mx",
+            "ng",
+            "nl",
+            "pk",
+            "qa",
+            "sa",
+            "se",
+            "sg",
+            "us",
+            "za",
+        ]), { minItems: 1, maxItems: 3 }),
+        articleLanguage: s.array("Article languages to include. Up to 3.", s.stringEnum("articleLanguage item value.", [
+            "am",
+            "ar",
+            "az",
+            "be",
+            "bg",
+            "bn",
+            "ca",
+            "ceb",
+            "cs",
+            "cy",
+            "da",
+            "de",
+            "el",
+            "en",
+            "es",
+            "et",
+            "eu",
+            "fa",
+            "fi",
+            "fr",
+            "gu",
+            "ha",
+            "haw",
+            "he",
+            "hi",
+            "hr",
+            "hu",
+            "hy",
+            "id",
+            "is",
+            "it",
+            "ja",
+            "ka",
+            "kk",
+            "kn",
+            "ko",
+            "ku",
+            "ky",
+            "lo",
+            "lt",
+            "lv",
+            "mk",
+            "ml",
+            "mn",
+            "mr",
+            "ms",
+            "ne",
+            "nl",
+            "no",
+            "or",
+            "pa",
+            "pl",
+            "ps",
+            "pt",
+            "ro",
+            "ru",
+            "sk",
+            "sl",
+            "so",
+            "sq",
+            "sr",
+            "sv",
+            "sw",
+            "ta",
+            "te",
+            "th",
+            "tl",
+            "tr",
+            "uk",
+            "ur",
+            "uz",
+            "vi",
+            "yo",
+            "zh",
+        ]), { minItems: 1, maxItems: 3 }),
+        articleType: s.array("Article types to include. Up to 3.", s.stringEnum("articleType item value.", ["editorial", "press_release", "regulatory_filing", "advisory"]), { minItems: 1, maxItems: 3 }),
+        date: s.object("Published-at window in epoch milliseconds. from must be before or equal to to.", {
+            from: s.integer("Inclusive start of the published-at window, in epoch milliseconds."),
+            to: s.integer("Inclusive end of the published-at window, in epoch milliseconds."),
+        }, { required: [] }),
+    }, {
+        required: [],
+        allOf: [
+            { not: { required: ["sourceDomain", "sourceCountry"] } },
+            { not: { required: ["sourceDomain", "articleLanguage"] } },
+            { not: { required: ["sourceDomain", "articleType"] } },
+            { not: { required: ["sourceCountry", "articleLanguage"] } },
+            { not: { required: ["sourceCountry", "articleType"] } },
+            { not: { required: ["articleLanguage", "articleType"] } },
+        ],
+    }),
+    sortBy: s.object("Result ordering. Defaults to newest for entity searches. Natural-language searches are always ordered by relevance.", {
+        type: s.stringEnum("Result ordering.", ["relevance", "newest"]),
+    }, { required: ["type"] }),
+    limit: s.integer("Maximum results to return. Defaults to 10.", { minimum: 1, maximum: 100 }),
+    cursor: s.nullable(s.string("Opaque next_cursor from the previous response, or null for the first page.", {
+        maxLength: 300,
+    })),
+    tags: requestTagsSchema,
+}, { required: ["searchBy"] });
+export const answer_researchInputSchema = s.object("Answer a research task input.", {
+    mode: s.stringEnum("`fast` prioritizes speed, with extra verification for people and companies; `ultra` supports deeper research (default).", ["fast", "ultra"]),
+    task: s.string("Research task. The agent selects company/profile lookups, web searches, or page reads. Include domains or URLs to focus the research.", { minLength: 1, maxLength: 2000 }),
+    json_format: s.object("Example answer object, not JSON Schema. Up to 8 levels, 500 values, and 16000 characters; unknowns may be null.", {}, { required: [], additionalProperties: s.unknown("json format entry value.") }),
+    timeoutOpts: partialTimeoutSchema,
+    tags: requestTagsSchema,
+    zdr: s.stringEnum("`enabled` turns on zero data retention. Returns 403 `ZDR_NOT_ENABLED` unless your organization has ZDR.", ["enabled", "disabled"]),
+}, { required: ["task"] });
+export const parse_fileInputSchema = s.object("Parse a file input.", {
+    extension: s.stringEnum("Optional file extension hint, such as pdf, docx, xlsx, pptx, html, json, csv, md, py, rtf, jpg, png, or txt.", [
+        "txt",
+        "text",
+        "md",
+        "markdown",
+        "html",
+        "htm",
+        "xhtml",
+        "xml",
+        "rss",
+        "atom",
+        "csv",
+        "tsv",
+        "yaml",
+        "yml",
+        "py",
+        "java",
+        "js",
+        "jsx",
+        "mjs",
+        "cjs",
+        "json",
+        "jsonl",
+        "ndjson",
+        "php",
+        "sh",
+        "bash",
+        "zsh",
+        "fish",
+        "rb",
+        "ts",
+        "tsx",
+        "rtf",
+        "srt",
+        "css",
+        "scss",
+        "less",
+        "styl",
+        "sass",
+        "svg",
+        "pdf",
+        "docx",
+        "doc",
+        "xlsx",
+        "xlsm",
+        "xlsb",
+        "xltx",
+        "xltm",
+        "xls",
+        "pptx",
+        "pptm",
+        "ppsx",
+        "ppsm",
+        "potx",
+        "potm",
+        "ppt",
+        "pps",
+        "pot",
+        "jpg",
+        "jpeg",
+        "jpe",
+        "png",
+        "gif",
+        "bmp",
+        "tiff",
+        "tif",
+        "webp",
+        "ppm",
+        "pbm",
+        "pgm",
+        "pnm",
+    ]),
+    includeLinks: s.boolean("Preserve hyperlinks in Markdown output"),
+    includeImages: s.boolean("Include image references in Markdown output"),
+    shortenBase64Images: s.boolean("Shorten base64-encoded image data in the Markdown output"),
+    useMainContentOnly: s.boolean("Extract only the main content from HTML-like inputs"),
+    ocr: s.boolean("Read text from images and scanned PDF pages. PDF page ranges still apply."),
+    pdf: s.object('PDF page-range options as a JSON object, e.g. {"start": 2, "end": 5}.', {
+        start: s.integer("First 1-based PDF page to parse.", { minimum: 1 }),
+        end: s.integer("Last PDF page to parse (1-based, inclusive). Defaults to the final page. Must be >= start.", {
+            minimum: 1,
+        }),
+    }, { required: [] }),
+    client: s.string("Optional client identifier used for usage attribution.", {
+        minLength: 1,
+        maxLength: 100,
+    }),
+    zdr: s.stringEnum("`enabled` turns on zero data retention. Returns 403 `ZDR_NOT_ENABLED` unless your organization has ZDR.", ["enabled", "disabled"]),
+    tags: s.describe(requestTagsSchema, "Comma-separated labels for filtering usage, e.g. `production,team-alpha`."),
+    fileUrl: s.string("Public HTTP(S) URL of the file to download and parse, up to 50 MiB.", {
+        format: "uri",
+    }),
+}, { required: ["fileUrl"] });
+export const map_urlsInputSchema = s.object("Map URLs input.", {
+    domain: s.string("Domain to map, e.g. `stripe.com`.", { minLength: 3 }),
+    includeSubdomains: s.boolean("Include URLs on subdomains."),
+    maxLinks: s.integer("Maximum number of URLs to return.", { minimum: 1, maximum: 100000 }),
+    sitemapUrl: s.string("Fetch this sitemap instead of discovering sitemaps. Must belong to the domain or a subdomain.", { format: "uri" }),
+    urlRegex: s.string("Regex pattern. Only URLs matching this pattern are returned and counted against maxLinks.", {
+        maxLength: 256,
+    }),
+    excludeUrlRegex: s.string("Regex pattern. URLs matching this pattern are not returned, even when they match urlRegex.", { maxLength: 256 }),
+    search: s.string("Filter URLs by a topic or phrase, most relevant first.", {
+        minLength: 2,
+        maxLength: 200,
+    }),
+    headers: s.object("HTTP headers for the target origin. Non-empty headers bypass caching.", {}, {
+        required: [],
+        additionalProperties: s.string("headers entry value.", {
+            maxLength: 8192,
+            pattern: "^[^\\r\\n]*$",
+        }),
+    }),
+    timeoutOpts: s.describe(lenientPartialTimeoutSchema, "Request deadline and what to return when it passes."),
+    zdr: s.stringEnum("`enabled` turns on zero data retention. Returns 403 `ZDR_NOT_ENABLED` unless your organization has ZDR.", ["enabled", "disabled"]),
+    tags: s.describe(requestTagsSchema, "Comma-separated labels for filtering usage, e.g. `production,team-alpha`."),
+}, { required: ["domain"] });
+export const crawl_websiteInputSchema = s.object("Crawl a website input.", {
+    url: s.string("Start URL, including `http://` or `https://`.", { minLength: 1, format: "uri" }),
+    maxPages: s.integer("Maximum pages to crawl.", { minimum: 1, maximum: 500 }),
+    maxDepth: s.integer("Maximum link depth from the starting URL (0 = only the starting page)", {
+        minimum: 0,
+    }),
+    urlRegex: s.string("Regex pattern. Only URLs matching this pattern will be followed and scraped. An automatic prefix scope in the form ^<starting URL> follows a redirect of the starting page.", { maxLength: 256 }),
+    excludeUrlRegex: s.string("Regex pattern. URLs matching this pattern are never followed or scraped, even when they match urlRegex. The starting URL is always scraped.", { maxLength: 256 }),
+    includeLinks: s.boolean("Preserve hyperlinks in the Markdown output (`html-conversion` only)."),
+    includeImages: s.boolean("Include image references in the Markdown output (`html-conversion` only)."),
+    shortenBase64Images: s.boolean("Truncate base64-encoded image data in the Markdown output (`html-conversion` only)."),
+    useMainContentOnly: s.boolean("Extract only the main content, stripping headers, footers, sidebars, and navigation"),
+    sourcePreference: s.array("Markdown sources in order of preference: `html-conversion` converts the page HTML, `markdown-direct` uses Markdown the site publishes.", s.stringEnum("sourcePreference item value.", ["html-conversion", "markdown-direct"]), { minItems: 1 }),
+    followSubdomains: s.boolean("When true, follow links on subdomains of the starting URL's domain (e.g. docs.example.com when starting from example.com). www and apex are always treated as equivalent."),
+    pdf: s.object("PDF handling. `start`/`end` limit parsing to an inclusive, 1-based page range.", {
+        shouldParse: s.boolean("When true, PDF pages are fetched and parsed. When false, PDF pages are skipped entirely (not included in results and not counted as failures)."),
+        start: s.integer("First 1-based PDF page to parse.", { minimum: 1 }),
+        end: s.integer("Last PDF page to parse (1-based, inclusive). Defaults to the final page. Must be >= start.", {
+            minimum: 1,
+        }),
+        ocr: s.boolean("Read scanned PDF pages with OCR; preserve pages that already have text."),
+    }, { required: [] }),
+    includeFrames: s.boolean("When true, the contents of iframes are rendered to Markdown for each crawled page."),
+    includeSelectors: s.nullable(s.array("Keep matching HTML subtrees before converting each page to Markdown.", s.string("includeSelectors item value.", { minLength: 1, maxLength: 2048 }), { maxItems: 50 })),
+    excludeSelectors: s.nullable(s.array("Remove matching elements after inclusions. Exclusions take precedence.", s.string("excludeSelectors item value.", { minLength: 1, maxLength: 2048 }), { maxItems: 50 })),
+    maxAgeMs: s.nullable(s.integer("Maximum cache age in milliseconds. Defaults to 1 day; `0` fetches fresh.", {
+        minimum: 0,
+        maximum: 2592000000,
+    })),
+    waitForMs: s.nullable(s.integer("Browser wait time in milliseconds after initial page load for each crawled page. Defaults to 3500 (3.5 seconds). Min: 0. Max: 30000 (30 seconds).", { minimum: 0, maximum: 30000 })),
+    settleAnimations: s.boolean("Wait briefly for CSS animations and transitions to settle before reading each page."),
+    stopAfterMs: s.integer("Soft crawl deadline in milliseconds. Returns pages collected before the next deadline check.", { minimum: 10000, maximum: 110000 }),
+    timeoutOpts: partialTimeoutSchema,
+    country: browserCountryCodeSchema,
+    zdr: s.stringEnum("`enabled` turns on zero data retention. Returns 403 `ZDR_NOT_ENABLED` unless your organization has ZDR.", ["enabled", "disabled"]),
+    tags: requestTagsSchema,
+}, { required: ["url"] });
+export const extract_dataInputSchema = s.object("Extract structured data input.", {
+    url: s.string("The starting website URL to crawl and extract from. Must include http:// or https://.", {
+        minLength: 1,
+        format: "uri",
+    }),
+    schema: s.object("JSON Schema (not an example object) for the returned object. Image fields include relevant page image references.", {}, { required: [], additionalProperties: s.unknown("schema entry value.") }),
+    instructions: s.string("Optional extraction guidance, such as which facts to prioritize or how to interpret fields in the schema.", { maxLength: 2000 }),
+    factCheck: s.boolean("Require facts stated on the page. Unsupported fields become null or empty."),
+    followSubdomains: s.boolean("When true, follow links on subdomains of the starting URL's domain."),
+    maxPages: s.integer("Maximum number of pages to analyze for extraction. Hard cap: 50. Defaults to 5.", {
+        minimum: 1,
+        maximum: 50,
+    }),
+    maxDepth: s.integer("Optional maximum link depth from the starting URL (0 = only the starting page). If omitted, there is no crawl depth limit.", { minimum: 0 }),
+    pdf: s.object("PDF handling. `start`/`end` limit parsing to an inclusive, 1-based page range.", {
+        shouldParse: s.boolean("When true, PDF pages are fetched and parsed. When false, PDF pages are skipped."),
+        start: s.integer("First 1-based PDF page to parse.", { minimum: 1 }),
+        end: s.integer("Last PDF page to parse (1-based, inclusive). Defaults to the final page. Must be >= start.", {
+            minimum: 1,
+        }),
+    }, { required: [] }),
+    includeFrames: s.boolean("When true, iframe contents are included in Markdown before extraction."),
+    maxAgeMs: s.nullable(s.integer("Return cached scrape results if a prior scrape for the same parameters is younger than this many milliseconds. Defaults to 7 days (604800000 ms).", { minimum: 0, maximum: 2592000000 })),
+    waitForMs: s.nullable(s.integer("Optional browser wait time in milliseconds after initial page load for each crawled page.", {
+        minimum: 0,
+        maximum: 30000,
+    })),
+    settleAnimations: s.boolean("Wait briefly for CSS animations and transitions to settle before reading each page."),
+    actions: s.nullable(s.array("Browser steps before page discovery. Requires a paid plan; defaults the crawl budget to 110000 ms.", webScrapeActionSchema, { maxItems: 5 })),
+    stopAfterMs: s.integer("Soft time budget for the crawl in milliseconds. Min: 10000 (10s). Max: 110000 (110s). Defaults to 80000 (80s), or 110000 (110s) when browser actions are provided.", { minimum: 10000, maximum: 110000 }),
+    timeoutOpts: partialTimeoutSchema,
+    zdr: s.stringEnum("`enabled` turns on zero data retention. Returns 403 `ZDR_NOT_ENABLED` unless your organization has ZDR.", ["enabled", "disabled"]),
+    tags: requestTagsSchema,
+}, { required: ["url", "schema"] });
+export const search_webInputSchema = s.object("Search the web input.", {
+    query: s.string("Search query. Accepts natural language as well as Google-style search operators such as `site:`, `-site:`, `inurl:`, `intitle:`, quoted phrases, and `OR`.", { minLength: 1, maxLength: 500 }),
+    numResults: s.integer("Number of results to request and return (1–100). Defaults to 10.", {
+        minimum: 1,
+        maximum: 100,
+    }),
+    includeDomains: s.array('Allowlist — only return results from these domains. Up to 100 domains. Example: ["arxiv.org", "github.com"].', s.string("includeDomains item value.", { minLength: 3 }), { maxItems: 100 }),
+    excludeDomains: s.array('Blocklist — drop results from these domains. Up to 100 domains. Example: ["pinterest.com", "reddit.com"].', s.string("excludeDomains item value.", { minLength: 3 }), { maxItems: 100 }),
+    freshness: s.stringEnum("Restrict results to content published within this window.", [
+        "last_24_hours",
+        "last_week",
+        "last_month",
+        "last_year",
+    ]),
+    country: s.stringEnum('Two-letter ISO 3166-1 alpha-2 country code to localize results to a specific country (maps to Google\'s `gl` parameter). Example: "us", "gb", "de".', [
+        "af",
+        "al",
+        "dz",
+        "as",
+        "ad",
+        "ao",
+        "ai",
+        "aq",
+        "ag",
+        "ar",
+        "am",
+        "aw",
+        "au",
+        "at",
+        "az",
+        "bs",
+        "bh",
+        "bd",
+        "bb",
+        "by",
+        "be",
+        "bz",
+        "bj",
+        "bm",
+        "bt",
+        "bo",
+        "ba",
+        "bw",
+        "bv",
+        "br",
+        "io",
+        "bn",
+        "bg",
+        "bf",
+        "bi",
+        "kh",
+        "cm",
+        "ca",
+        "cv",
+        "ky",
+        "cf",
+        "td",
+        "cl",
+        "cn",
+        "cx",
+        "cc",
+        "co",
+        "km",
+        "cg",
+        "cd",
+        "ck",
+        "cr",
+        "ci",
+        "hr",
+        "cu",
+        "cy",
+        "cz",
+        "dk",
+        "dj",
+        "dm",
+        "do",
+        "ec",
+        "eg",
+        "sv",
+        "gq",
+        "er",
+        "ee",
+        "et",
+        "fk",
+        "fo",
+        "fj",
+        "fi",
+        "fr",
+        "gf",
+        "pf",
+        "tf",
+        "ga",
+        "gm",
+        "ge",
+        "de",
+        "gh",
+        "gi",
+        "gr",
+        "gl",
+        "gd",
+        "gp",
+        "gu",
+        "gt",
+        "gn",
+        "gw",
+        "gy",
+        "ht",
+        "hm",
+        "va",
+        "hn",
+        "hk",
+        "hu",
+        "is",
+        "in",
+        "id",
+        "ir",
+        "iq",
+        "ie",
+        "il",
+        "it",
+        "jm",
+        "jp",
+        "jo",
+        "kz",
+        "ke",
+        "ki",
+        "kp",
+        "kr",
+        "kw",
+        "kg",
+        "la",
+        "lv",
+        "lb",
+        "ls",
+        "lr",
+        "ly",
+        "li",
+        "lt",
+        "lu",
+        "mo",
+        "mk",
+        "mg",
+        "mw",
+        "my",
+        "mv",
+        "ml",
+        "mt",
+        "mh",
+        "mq",
+        "mr",
+        "mu",
+        "yt",
+        "mx",
+        "fm",
+        "md",
+        "mc",
+        "mn",
+        "ms",
+        "ma",
+        "mz",
+        "mm",
+        "na",
+        "nr",
+        "np",
+        "nl",
+        "an",
+        "nc",
+        "nz",
+        "ni",
+        "ne",
+        "ng",
+        "nu",
+        "nf",
+        "mp",
+        "no",
+        "om",
+        "pk",
+        "pw",
+        "ps",
+        "pa",
+        "pg",
+        "py",
+        "pe",
+        "ph",
+        "pn",
+        "pl",
+        "pt",
+        "pr",
+        "qa",
+        "re",
+        "ro",
+        "ru",
+        "rw",
+        "sh",
+        "kn",
+        "lc",
+        "pm",
+        "vc",
+        "ws",
+        "sm",
+        "st",
+        "sa",
+        "sn",
+        "rs",
+        "sc",
+        "sl",
+        "sg",
+        "sk",
+        "si",
+        "sb",
+        "so",
+        "za",
+        "gs",
+        "es",
+        "lk",
+        "sd",
+        "sr",
+        "sj",
+        "sz",
+        "se",
+        "ch",
+        "sy",
+        "tw",
+        "tj",
+        "tz",
+        "th",
+        "tl",
+        "tg",
+        "tk",
+        "to",
+        "tt",
+        "tn",
+        "tr",
+        "tm",
+        "tc",
+        "tv",
+        "ug",
+        "ua",
+        "ae",
+        "gb",
+        "us",
+        "um",
+        "uy",
+        "uz",
+        "vu",
+        "ve",
+        "vn",
+        "vg",
+        "vi",
+        "wf",
+        "eh",
+        "ye",
+        "zm",
+        "zw",
+    ]),
+    languages: s.anyOf('Languages to return results in, as BCP 47 language codes such as `en` or `de`, or "all" for any language. Defaults to "all". Example: ["en", "de"].', [
+        s.stringEnum("languages value.", ["all"]),
+        s.array("languages value.", s.stringEnum("languages item value.", [
+            "am",
+            "ar",
+            "az",
+            "be",
+            "bg",
+            "bn",
+            "ca",
+            "ceb",
+            "cs",
+            "cy",
+            "da",
+            "de",
+            "el",
+            "en",
+            "es",
+            "et",
+            "eu",
+            "fa",
+            "fi",
+            "fr",
+            "gu",
+            "ha",
+            "haw",
+            "he",
+            "hi",
+            "hr",
+            "hu",
+            "hy",
+            "id",
+            "is",
+            "it",
+            "ja",
+            "ka",
+            "kk",
+            "kn",
+            "ko",
+            "ku",
+            "ky",
+            "lo",
+            "lt",
+            "lv",
+            "mk",
+            "ml",
+            "mn",
+            "mr",
+            "ms",
+            "ne",
+            "nl",
+            "no",
+            "or",
+            "pa",
+            "pl",
+            "ps",
+            "pt",
+            "ro",
+            "ru",
+            "sk",
+            "sl",
+            "so",
+            "sq",
+            "sr",
+            "sv",
+            "sw",
+            "ta",
+            "te",
+            "th",
+            "tl",
+            "tr",
+            "uk",
+            "ur",
+            "uz",
+            "vi",
+            "yo",
+            "zh",
+        ]), { minItems: 1 }),
+    ]),
+    queryFanout: s.boolean("Currently has no effect."),
+    markdownOptions: s.nullable(s.object("Inline Markdown scraping for each result. Set `enabled: true` to activate.", {
+        enabled: s.boolean("Scrape each result to Markdown. Adds 1 credit per result with Markdown."),
+        includeLinks: s.boolean("Keep hyperlinks in the Markdown."),
+        includeImages: s.boolean("Emit image references in the Markdown."),
+        shortenBase64Images: s.boolean("Truncate inline base64 image payloads to keep responses small."),
+        useMainContentOnly: s.boolean("Strip nav, header, footer, and sidebar — keep only the primary article content."),
+        pdf: s.object("PDF handling. `start`/`end` limit parsing to an inclusive, 1-based page range.", {
+            shouldParse: s.boolean("Parse PDF URLs. When false, PDF results are skipped with WEBSITE_ACCESS_ERROR."),
+            start: s.integer("First 1-based PDF page to parse.", { minimum: 1 }),
+            end: s.integer("Last PDF page to parse (1-based, inclusive). Defaults to the final page. Must be >= start.", { minimum: 1 }),
+        }, { required: [] }),
+        includeFrames: s.boolean("Render iframe contents into the Markdown."),
+        maxAgeMs: s.nullable(s.integer("Maximum cache age in milliseconds for result page content. Defaults to 180 days (15552000000 ms) when Markdown is requested, or 365 days (31536000000 ms) when only highlights are requested. Explicit values override either default. Maximum: 365 days. Set to 0 to force a fresh scrape.", { minimum: 0, maximum: 31536000000 })),
+        waitForMs: s.nullable(s.integer("Extra wait after page load before rendering, in ms (0–30000). Useful for JS-heavy pages.", {
+            minimum: 0,
+            maximum: 30000,
+        })),
+        timeoutOpts: scrapeTimeoutSchema,
+    }, { required: [] })),
+    highlightsOptions: s.nullable(s.object("Passages from each result page that are relevant to the query. Pages are read with the `markdownOptions` settings.", {
+        enabled: s.boolean("Return relevant passages for each result. Adds 1 credit per 10 results."),
+        maxCharacters: s.integer("Maximum combined length of passages per result.", {
+            minimum: 100,
+            maximum: 20000,
+        }),
+    }, { required: [] })),
+    descriptionMaxCharacters: s.nullable(s.integer("Maximum length of each result's `description`, in characters.", { minimum: 0 })),
+    timeoutOpts: partialTimeoutSchema,
+    zdr: s.stringEnum("`enabled` turns on zero data retention. Returns 403 `ZDR_NOT_ENABLED` unless your organization has ZDR.", ["enabled", "disabled"]),
+    tags: requestTagsSchema,
+}, { required: ["query"] });
+export const enrich_personInputSchema = s.object("Enrich a person input.", {
+    social_urls: s.array("Public profile URLs for the person. A person-profile URL can identify the person without a name.", s.string("social urls item value.", { format: "uri" }), { minItems: 1, maxItems: 20 }),
+    name: s.object("Person name. Without an email or person-profile URL, provide both first and last name plus company, education, or location.", {
+        first: s.string("First or given name.", { minLength: 1, maxLength: 100 }),
+        last: s.string("Last or family name.", { minLength: 1, maxLength: 100 }),
+    }, { required: [] }),
+    email: s.string("Email address of the person to find.", { maxLength: 320, format: "email" }),
+    company: s.object("Company context to help identify the person. Provide a name or domain.", {
+        name: s.string("Name of a company associated with the person.", {
+            minLength: 1,
+            maxLength: 200,
+        }),
+        domain: s.string("Website domain of a company associated with the person.", {
+            minLength: 1,
+            maxLength: 253,
+        }),
+    }, { required: [] }),
+    education: s.array("Education history to help distinguish people with similar names.", s.object("education item value.", {
+        institution: s.object("School or university, identified by name or domain.", {
+            name: s.string("Name of the school or university.", { minLength: 1, maxLength: 200 }),
+            domain: s.string("Website domain of the school or university.", {
+                minLength: 1,
+                maxLength: 253,
+            }),
+        }, { required: [] }),
+        degree: s.string("Degree or qualification earned.", { minLength: 1, maxLength: 200 }),
+        field_of_study: s.string("Subject or major studied.", { minLength: 1, maxLength: 200 }),
+        graduation_year: s.integer("Four-digit graduation year.", {
+            minimum: 1900,
+            maximum: 2200,
+        }),
+    }, { required: [] }), { minItems: 1, maxItems: 10 }),
+    location: s.object("Location context to help identify the person. Provide a city, region, or country.", {
+        city: s.string("City associated with the person.", { minLength: 1, maxLength: 200 }),
+        region: s.string("State, province, or region associated with the person.", {
+            minLength: 1,
+            maxLength: 200,
+        }),
+        country: s.string("Country associated with the person.", { minLength: 1, maxLength: 200 }),
+    }, { required: [] }),
+    timeoutOpts: partialTimeoutSchema,
+    zdr: s.stringEnum("`enabled` turns on zero data retention. Returns 403 `ZDR_NOT_ENABLED` unless your organization has ZDR.", ["enabled", "disabled"]),
+    tags: requestTagsSchema,
+}, { required: [] });
+export const retrieve_brandInputSchema = s.oneOf([
+    brandRetrieveByDomainRequestSchema,
+    brandRetrieveByNameRequestSchema,
+    brandRetrieveByEmailRequestSchema,
+    brandRetrieveByTickerRequestSchema,
+    brandRetrieveByDirectUrlRequestSchema,
+    brandRetrieveFromTransactionRequestSchema,
+], {
+    description: "Retrieve a brand input.",
+});
+export const search_brandsInputSchema = s.object("Auto-complete Brand input.", {
+    query: s.string("Search term, matched against the fields selected by queryBy (e.g. 'stripe', 'stripe.com', 'stri').", { minLength: 1, maxLength: 100 }),
+    country: s.stringEnum("Only return brands in this country, as an uppercase ISO 3166-1 alpha-2 code such as US or GB.", [
+        "AD",
+        "AE",
+        "AF",
+        "AG",
+        "AI",
+        "AL",
+        "AM",
+        "AO",
+        "AQ",
+        "AR",
+        "AS",
+        "AT",
+        "AU",
+        "AW",
+        "AX",
+        "AZ",
+        "BA",
+        "BB",
+        "BD",
+        "BE",
+        "BF",
+        "BG",
+        "BH",
+        "BI",
+        "BJ",
+        "BL",
+        "BM",
+        "BN",
+        "BO",
+        "BQ",
+        "BR",
+        "BS",
+        "BT",
+        "BV",
+        "BW",
+        "BY",
+        "BZ",
+        "CA",
+        "CC",
+        "CD",
+        "CF",
+        "CG",
+        "CH",
+        "CI",
+        "CK",
+        "CL",
+        "CM",
+        "CN",
+        "CO",
+        "CR",
+        "CU",
+        "CV",
+        "CW",
+        "CX",
+        "CY",
+        "CZ",
+        "DE",
+        "DJ",
+        "DK",
+        "DM",
+        "DO",
+        "DZ",
+        "EC",
+        "EE",
+        "EG",
+        "EH",
+        "ER",
+        "ES",
+        "ET",
+        "FI",
+        "FJ",
+        "FK",
+        "FM",
+        "FO",
+        "FR",
+        "GA",
+        "GB",
+        "GD",
+        "GE",
+        "GF",
+        "GG",
+        "GH",
+        "GI",
+        "GL",
+        "GM",
+        "GN",
+        "GP",
+        "GQ",
+        "GR",
+        "GS",
+        "GT",
+        "GU",
+        "GW",
+        "GY",
+        "HK",
+        "HM",
+        "HN",
+        "HR",
+        "HT",
+        "HU",
+        "ID",
+        "IE",
+        "IL",
+        "IM",
+        "IN",
+        "IO",
+        "IQ",
+        "IR",
+        "IS",
+        "IT",
+        "JE",
+        "JM",
+        "JO",
+        "JP",
+        "KE",
+        "KG",
+        "KH",
+        "KI",
+        "KM",
+        "KN",
+        "KP",
+        "KR",
+        "KW",
+        "KY",
+        "KZ",
+        "LA",
+        "LB",
+        "LC",
+        "LI",
+        "LK",
+        "LR",
+        "LS",
+        "LT",
+        "LU",
+        "LV",
+        "LY",
+        "MA",
+        "MC",
+        "MD",
+        "ME",
+        "MF",
+        "MG",
+        "MH",
+        "MK",
+        "ML",
+        "MM",
+        "MN",
+        "MO",
+        "MP",
+        "MQ",
+        "MR",
+        "MS",
+        "MT",
+        "MU",
+        "MV",
+        "MW",
+        "MX",
+        "MY",
+        "MZ",
+        "NA",
+        "NC",
+        "NE",
+        "NF",
+        "NG",
+        "NI",
+        "NL",
+        "NO",
+        "NP",
+        "NR",
+        "NU",
+        "NZ",
+        "OM",
+        "PA",
+        "PE",
+        "PF",
+        "PG",
+        "PH",
+        "PK",
+        "PL",
+        "PM",
+        "PN",
+        "PR",
+        "PS",
+        "PT",
+        "PW",
+        "PY",
+        "QA",
+        "RE",
+        "RO",
+        "RS",
+        "RU",
+        "RW",
+        "SA",
+        "SB",
+        "SC",
+        "SD",
+        "SE",
+        "SG",
+        "SH",
+        "SI",
+        "SJ",
+        "SK",
+        "SL",
+        "SM",
+        "SN",
+        "SO",
+        "SR",
+        "SS",
+        "ST",
+        "SV",
+        "SX",
+        "SY",
+        "SZ",
+        "TC",
+        "TD",
+        "TF",
+        "TG",
+        "TH",
+        "TJ",
+        "TK",
+        "TL",
+        "TM",
+        "TN",
+        "TO",
+        "TR",
+        "TT",
+        "TV",
+        "TW",
+        "TZ",
+        "UA",
+        "UG",
+        "UM",
+        "US",
+        "UY",
+        "UZ",
+        "VA",
+        "VC",
+        "VE",
+        "VG",
+        "VI",
+        "VN",
+        "VU",
+        "WF",
+        "WS",
+        "YE",
+        "YT",
+        "ZA",
+        "ZM",
+        "ZW",
+    ]),
+    language: s.stringEnum("Only return brands with this primary language, such as english or french.", [
+        "afrikaans",
+        "albanian",
+        "amharic",
+        "arabic",
+        "armenian",
+        "assamese",
+        "aymara",
+        "azeri",
+        "basque",
+        "belarusian",
+        "bengali",
+        "bosnian",
+        "bulgarian",
+        "burmese",
+        "cantonese",
+        "catalan",
+        "cebuano",
+        "chinese",
+        "corsican",
+        "croatian",
+        "czech",
+        "danish",
+        "dutch",
+        "english",
+        "esperanto",
+        "estonian",
+        "farsi",
+        "fijian",
+        "finnish",
+        "french",
+        "galician",
+        "georgian",
+        "german",
+        "greek",
+        "guarani",
+        "gujarati",
+        "haitian-creole",
+        "hausa",
+        "hawaiian",
+        "hebrew",
+        "hindi",
+        "hmong",
+        "hungarian",
+        "icelandic",
+        "igbo",
+        "indonesian",
+        "irish",
+        "italian",
+        "japanese",
+        "javanese",
+        "kannada",
+        "kazakh",
+        "khmer",
+        "kinyarwanda",
+        "korean",
+        "kurdish",
+        "kyrgyz",
+        "lao",
+        "latin",
+        "latvian",
+        "lingala",
+        "lithuanian",
+        "luxembourgish",
+        "macedonian",
+        "malagasy",
+        "malay",
+        "malayalam",
+        "maltese",
+        "maori",
+        "marathi",
+        "mongolian",
+        "nepali",
+        "norwegian",
+        "odia",
+        "oromo",
+        "pashto",
+        "pidgin",
+        "polish",
+        "portuguese",
+        "punjabi",
+        "quechua",
+        "romanian",
+        "russian",
+        "samoan",
+        "scottish-gaelic",
+        "serbian",
+        "sesotho",
+        "shona",
+        "sindhi",
+        "sinhala",
+        "slovak",
+        "slovene",
+        "somali",
+        "spanish",
+        "sundanese",
+        "swahili",
+        "swedish",
+        "tagalog",
+        "tajik",
+        "tamil",
+        "tatar",
+        "telugu",
+        "thai",
+        "tibetan",
+        "tigrinya",
+        "tongan",
+        "tswana",
+        "turkish",
+        "turkmen",
+        "ukrainian",
+        "urdu",
+        "uyghur",
+        "uzbek",
+        "vietnamese",
+        "welsh",
+        "wolof",
+        "xhosa",
+        "yiddish",
+        "yoruba",
+        "zulu",
+    ]),
+    autocomplete: s.boolean("Whether the search term matches by prefix, so partial words match as they are typed (e.g. 'stri' matches Stripe). Set to false to match whole words only."),
+    queryBy: s.array("Fields to match the search term against, as a comma-separated list or repeated parameter: 'name', 'domain', or both. Defaults to both.", s.stringEnum("queryBy item value.", ["name", "domain"]), { minItems: 1 }),
+    typoTolerance: s.integer("Maximum number of typos tolerated when matching, from 0 to 2. Defaults to 0 (no typo tolerance).", { minimum: 0, maximum: 2 }),
+    tags: s.describe(requestTagsSchema, "Comma-separated labels for filtering usage, e.g. `production,team-alpha`."),
+}, { required: ["query"] });
+export const extract_styleguideInputSchema = s.object("Extract a styleguide input.", {
+    domain: s.string("Domain name to extract styleguide from (e.g., 'example.com', 'google.com'). The domain will be automatically normalized and validated. You must provide either 'domain' or 'directUrl', but not both.", { minLength: 3 }),
+    directUrl: s.string("Exact URL to inspect. Provide either `domain` or `directUrl`, not both.", {
+        format: "uri",
+    }),
+    maxAgeMs: s.nullable(s.integer("Maximum age of cached brand data in ms. Defaults to 3 months; clamped to 0–1 year. `0` refreshes.")),
+    timeoutOpts: s.describe(scrapeTimeoutSchema, "Request deadline and what to return when it passes."),
+    colorScheme: s.stringEnum("Optional browser color scheme to emulate for websites that respond to prefers-color-scheme. This value is part of the styleguide cache key.", ["light", "dark"]),
+    zdr: s.stringEnum("`enabled` turns on zero data retention. Returns 403 `ZDR_NOT_ENABLED` unless your organization has ZDR.", ["enabled", "disabled"]),
+    tags: s.describe(requestTagsSchema, "Comma-separated labels for filtering usage, e.g. `production,team-alpha`."),
+}, { required: [] });
+export const extract_fontsInputSchema = s.object("Extract fonts input.", {
+    directUrl: s.string("Exact page to inspect. Provide either `domain` or `directUrl`.", {
+        format: "uri",
+    }),
+    domain: s.string("Domain name to extract fonts from (e.g., 'example.com', 'google.com'). The domain will be automatically normalized and validated. You must provide either 'domain' or 'directUrl', but not both.", { minLength: 3 }),
+    maxAgeMs: s.nullable(s.integer("Maximum age of cached brand data in ms. Defaults to 3 months; clamped to 0–1 year. `0` refreshes.")),
+    timeoutOpts: s.describe(scrapeTimeoutSchema, "Request deadline and what to return when it passes."),
+    tags: s.describe(requestTagsSchema, "Comma-separated labels for filtering usage, e.g. `production,team-alpha`."),
+}, { required: [] });
+export const classify_naicsInputSchema = s.object("Classify NAICS codes input.", {
+    input: s.string("Brand domain or title to retrieve NAICS code for. If a valid domain is provided, it will be used for classification, otherwise, we will search for the brand using the provided title.", { minLength: 4 }),
+    minResults: s.integer("Minimum number of NAICS codes to return. Must be at least 1. Defaults to 1.", {
+        minimum: 1,
+        maximum: 10,
+    }),
+    maxResults: s.integer("Maximum number of NAICS codes to return. Must be between 1 and 10. Defaults to 5.", {
+        minimum: 1,
+        maximum: 10,
+    }),
+    timeoutOpts: s.describe(partialTimeoutSchema, "Request deadline and what to return when it passes."),
+    zdr: s.stringEnum("`enabled` turns on zero data retention. Returns 403 `ZDR_NOT_ENABLED` unless your organization has ZDR.", ["enabled", "disabled"]),
+    tags: s.describe(requestTagsSchema, "Comma-separated labels for filtering usage, e.g. `production,team-alpha`."),
+}, { required: ["input"] });
+export const classify_sicInputSchema = s.object("Classify SIC codes input.", {
+    input: s.string("Brand domain or title to retrieve SIC code for. If a valid domain is provided, it will be used for classification, otherwise, we will search for the brand using the provided title.", { minLength: 4 }),
+    type: s.stringEnum("SIC dataset: `original_sic` (1987) or `latest_sec` (current SEC list).", [
+        "original_sic",
+        "latest_sec",
+    ]),
+    minResults: s.integer("Minimum number of SIC codes to return. Must be at least 1. Defaults to 1.", {
+        minimum: 1,
+        maximum: 10,
+    }),
+    maxResults: s.integer("Maximum number of SIC codes to return. Must be between 1 and 10. Defaults to 5.", {
+        minimum: 1,
+        maximum: 10,
+    }),
+    timeoutOpts: s.describe(partialTimeoutSchema, "Request deadline and what to return when it passes."),
+    zdr: s.stringEnum("`enabled` turns on zero data retention. Returns 403 `ZDR_NOT_ENABLED` unless your organization has ZDR.", ["enabled", "disabled"]),
+    tags: s.describe(requestTagsSchema, "Comma-separated labels for filtering usage, e.g. `production,team-alpha`."),
+}, { required: ["input"] });
+export const prefetch_brandInputSchema = s.object("Prefetch brand data input.", {
+    type: s.stringEnum("Data to prefetch.", ["brand", "styleguide"]),
+    identifier: utilityPrefetchIdentifierSchema,
+    timeoutOpts: timeoutSchema,
+    tags: requestTagsSchema,
+}, { required: ["type", "identifier"] });
+export const create_monitorInputSchema = s.object("Create a monitor input.", {
+    mode: monitorsModeSchema,
+    name: s.string("Display name for the monitor.", { minLength: 1, maxLength: 200 }),
+    tags: s.array("Labels for filtering monitors, their changes, and their usage.", s.string("tags item value.", { minLength: 1, maxLength: 50 }), { maxItems: 20, uniqueItems: true }),
+    target: monitorsTargetSchema,
+    change_detection: monitorsChangeDetectionSchema,
+    schedule: monitorsScheduleSchema,
+    webhook: monitorsNullableWebhookConfigSchema,
+}, { required: ["name", "target"] });
+export const list_monitorsInputSchema = s.object("List monitors input.", {
+    q: s.string("Free-text search term, matched against the fields named in `search_by`.", {
+        maxLength: 200,
+    }),
+    search_by: s.nullable(s.array("Fields to search with `q`. Defaults to all fields; page and extract targets can have instructions.", s.stringEnum("search by item value.", ["name", "url", "instructions", "tags"]), {})),
+    search_type: s.stringEnum("`prefix` for as-you-type prefix matching (default), `exact` for full-token matching.", [
+        "exact",
+        "prefix",
+    ]),
+    status: s.stringEnum("Filter monitors by lifecycle status.", ["active", "paused", "failed"]),
+    target_type: s.stringEnum("Filter by target type.", ["page", "sitemap", "extract"]),
+    change_detection_type: s.stringEnum("Filter by change detection type.", ["exact", "semantic"]),
+    tags: s.nullable(s.array("Comma-separated list of tags to filter by (matches monitors having any of them).", s.string("tags item value.", { minLength: 1, maxLength: 50 }), { maxItems: 20 })),
+    tag: s.string("Filter to items that have this tag."),
+    limit: s.integer("Maximum number of items to return per page (1-100). Defaults to 25.", {
+        minimum: 1,
+        maximum: 100,
+    }),
+    cursor: s.string("Opaque pagination cursor from a previous response."),
+}, { required: [] });
+export const get_monitorInputSchema = s.object("Retrieve a monitor input.", {
+    monitor_id: s.string("ID of the monitor."),
+}, { required: ["monitor_id"] });
+export const update_monitorInputSchema = s.object("Update a monitor input.", {
+    name: s.string("Display name for the monitor.", { minLength: 1, maxLength: 200 }),
+    tags: s.array("Labels for filtering monitors, their changes, and their usage.", s.string("tags item value.", { minLength: 1, maxLength: 50 }), { maxItems: 20, uniqueItems: true }),
+    status: s.stringEnum("Set `paused` to stop scheduled runs or `active` to resume them.", ["active", "paused"]),
+    target: monitorsTargetSchema,
+    change_detection: monitorsChangeDetectionSchema,
+    schedule: monitorsScheduleSchema,
+    webhook: s.describe(monitorsNullableWebhookConfigSchema, "Set to null to remove the webhook. Changing `url` issues a new secret."),
+    monitor_id: s.string("ID of the monitor."),
+}, { required: ["monitor_id"] });
+export const delete_monitorInputSchema = s.object("Delete a monitor input.", {
+    monitor_id: s.string("ID of the monitor."),
+}, { required: ["monitor_id"] });
+export const list_monitor_runsInputSchema = s.object("List monitor runs input.", {
+    monitor_id: s.string("ID of the monitor."),
+    status: {
+        allOf: [monitorsRunStatusSchema, s.unknown("Filter runs by lifecycle status.")],
+        description: "Filter runs by lifecycle status.",
+    },
+    limit: s.integer("Maximum number of items to return per page (1-100). Defaults to 25.", {
+        minimum: 1,
+        maximum: 100,
+    }),
+    cursor: s.string("Opaque pagination cursor from a previous response."),
+}, { required: ["monitor_id"] });
+export const get_monitor_runInputSchema = s.object("Retrieve a monitor run input.", {
+    monitor_id: s.string("ID of the monitor."),
+    run_id: s.string("ID of the monitor run."),
+}, { required: ["monitor_id", "run_id"] });
+export const list_monitor_changesInputSchema = s.object("List monitor changes input.", {
+    monitor_id: s.string("ID of the monitor."),
+    tag: s.string("Filter to items that have this tag."),
+    since: s.string("Only include items at or after this ISO 8601 timestamp.", {
+        format: "date-time",
+    }),
+    until: s.string("Only include items before this ISO 8601 timestamp.", { format: "date-time" }),
+    limit: s.integer("Maximum number of items to return per page (1-100). Defaults to 25.", {
+        minimum: 1,
+        maximum: 100,
+    }),
+    cursor: s.string("Opaque pagination cursor from a previous response."),
+}, { required: ["monitor_id"] });
+export const list_account_runsInputSchema = s.object("List runs for all monitors input.", {
+    status: {
+        allOf: [monitorsRunStatusSchema, s.unknown("Filter runs by lifecycle status.")],
+        description: "Filter runs by lifecycle status.",
+    },
+    limit: s.integer("Maximum number of items to return per page (1-100). Defaults to 25.", {
+        minimum: 1,
+        maximum: 100,
+    }),
+    cursor: s.string("Opaque pagination cursor from a previous response."),
+}, { required: [] });
+export const list_monitor_credit_usageInputSchema = s.object("Retrieve monitor credit usage input.", {
+    since: s.string("Only include items at or after this ISO 8601 timestamp.", {
+        format: "date-time",
+    }),
+    until: s.string("Only include items before this ISO 8601 timestamp.", { format: "date-time" }),
+}, { required: [] });
+export const get_monitor_limitsInputSchema = s.object("Retrieve monitor limits input.", {}, { required: [], additionalProperties: true });
+export const list_changesInputSchema = s.object("List changes for all monitors input.", {
+    monitor_id: s.string("Filter changes to a single monitor."),
+    target_type: s.stringEnum("Filter by target type.", ["page", "sitemap", "extract"]),
+    change_detection_type: s.stringEnum("Filter by change detection type.", ["exact", "semantic"]),
+    tag: s.string("Filter to items that have this tag."),
+    since: s.string("Only include items at or after this ISO 8601 timestamp.", {
+        format: "date-time",
+    }),
+    until: s.string("Only include items before this ISO 8601 timestamp.", { format: "date-time" }),
+    limit: s.integer("Maximum number of items to return per page (1-100). Defaults to 25.", {
+        minimum: 1,
+        maximum: 100,
+    }),
+    cursor: s.string("Opaque pagination cursor from a previous response."),
+}, { required: [] });
+export const get_changeInputSchema = s.object("Retrieve a monitor change input.", {
+    change_id: s.string("ID of the detected change."),
+}, { required: ["change_id"] });
+export const run_monitor_nowInputSchema = s.object("Run a monitor now input.", {
+    monitor_id: s.string("ID of the monitor."),
+}, { required: ["monitor_id"] });
+export const rotate_monitor_webhook_secretInputSchema = s.object("Rotate a monitor webhook secret input.", {
+    monitor_id: s.string("ID of the monitor."),
+}, { required: ["monitor_id"] });
+export const submit_batchInputSchema = s.object("Submit a batch input.", {
+    input: s.oneOf([
+        s.object("Scrape a list of up to 100,000 URLs.", {
+            mode: s.stringEnum("Scrape the pages in `data.urls`.", ["scrape"]),
+            data: batchUnifiedScrapeDataSchema,
+        }, { required: ["mode", "data"] }),
+        s.object("Crawl pages starting from a URL or from a domain's sitemap.", {
+            mode: s.stringEnum("Discover and scrape pages from `data.source`.", ["crawl"]),
+            data: batchUnifiedCrawlDataSchema,
+        }, { required: ["mode", "data"] }),
+    ], {
+        description: "Choose a URL list or a site crawl.",
+    }),
+    webhookUrl: s.string("Legacy URL notified when the batch finishes. Preserves one best-effort attempt. Cannot be combined with webhook.", { format: "uri" }),
+    webhook: s.object("Where to send the batch's final-status event. Omit `retry` for one attempt; `{}` uses the default retry schedule.", {
+        url: s.string("Public HTTP(S) URL that receives batch completion, failure, or cancellation events.", {
+            format: "uri",
+        }),
+        retry: webhookRetrySchema,
+    }, { required: ["url"] }),
+    tags: s.array("Tags stored on the batch. Filter the batch list by them later.", s.string("tags item value.", { minLength: 1, maxLength: 50 }), { maxItems: 20 }),
+    idempotencyKey: s.string("Unique key per submission. Retrying with the same key and body returns the original batch; a different body returns `409`.", { maxLength: 200 }),
+}, { required: ["input"] });
+export const list_batchesInputSchema = s.object("List batches input.", {
+    shouldIncludeUnified: s.boolean("Include batches submitted with Scrape Anything formats. Defaults to false."),
+    limit: s.integer("Batches per page. Defaults to 25.", { minimum: 1, maximum: 100 }),
+    cursor: s.string("Cursor from the previous page."),
+    status: s.stringEnum("Filter by status.", ["queued", "running", "cancelling", "completed", "cancelled", "failed"]),
+    q: s.string("Free-text search term, matched against the batch id, crawl source (start URL or sitemap domain), and tags.", { maxLength: 200 }),
+    search_type: s.stringEnum("`prefix` for as-you-type prefix matching (default), `exact` for full-token matching.", [
+        "exact",
+        "prefix",
+    ]),
+    tags: s.anyOf("Tags to filter by (matches batches having any of them). Pass repeated `tags` params or one comma-separated list, e.g. `tags=docs,competitor`.", [s.string("tags value."), s.array("tags value.", s.string("tags item value."), {})]),
+}, { required: [] });
+export const get_batchInputSchema = s.object("Retrieve a batch input.", {
+    batch_id: s.string("Batch ID."),
+}, { required: ["batch_id"] });
+export const delete_batchInputSchema = s.object("Delete a batch input.", {
+    batch_id: s.string("Batch ID."),
+}, { required: ["batch_id"] });
+export const get_batch_resultsInputSchema = s.object("List batch results input.", {
+    batch_id: s.string("Batch ID."),
+    limit: s.integer("Records per page. Defaults to 25. A page can close early so its payload stays under ~8 MB; rely on next_cursor rather than counting records.", { minimum: 1, maximum: 100 }),
+    cursor: s.string("next_cursor from the previous page.", { pattern: "^\\d+:\\d+$" }),
+}, { required: ["batch_id"] });
+export const cancel_batchInputSchema = s.object("Cancel a batch input.", {
+    batch_id: s.string("Batch ID."),
+}, { required: ["batch_id"] });
+export const search_companiesInputSchema = s.object("Search companies input.", {
+    query: s.string("Describe the companies to find.", { minLength: 1, maxLength: 500 }),
+    filters: companySearchFiltersSchema,
+    limit: s.integer("Maximum number of results to return (1-100).", { minimum: 1, maximum: 100 }),
+    cursor: s.string("Use next_cursor to fetch the next page.", { maxLength: 64 }),
+    tags: requestTagsSchema,
+}, { required: ["query"] });