builtwith-api 1.0.6 → 3.1.0

package/dist/cli.js

@@ -0,0 +1,742 @@
+#!/usr/bin/env node
+
+// src/config.ts
+var VALID_RESPONSE_TYPES = {
+  XML: "xml",
+  JSON: "json",
+  TXT: "txt",
+  CSV: "csv",
+  TSV: "tsv"
+};
+
+// src/schemas.ts
+import { z } from "zod/v4";
+var ResponseFormatSchema = z.enum(["xml", "json", "txt", "csv", "tsv"]);
+var ClientOptionsSchema = z.strictObject({
+  responseFormat: ResponseFormatSchema.optional()
+});
+var DomainParamsSchema = z.strictObject({
+  hideAll: z.boolean().optional(),
+  hideDescriptionAndLinks: z.boolean().optional(),
+  onlyLiveTechnologies: z.boolean().optional(),
+  noMetaData: z.boolean().optional(),
+  noAttributeData: z.boolean().optional(),
+  noPII: z.boolean().optional(),
+  firstDetectedRange: z.string().optional(),
+  lastDetectedRange: z.string().optional()
+});
+var ListsParamsSchema = z.strictObject({
+  includeMetaData: z.boolean().optional(),
+  offset: z.string().optional(),
+  since: z.string().optional()
+});
+var TrendsParamsSchema = z.strictObject({
+  date: z.string().optional()
+});
+var CompanyToUrlParamsSchema = z.strictObject({
+  tld: z.string().optional(),
+  amount: z.number().optional()
+});
+var TrustParamsSchema = z.strictObject({
+  words: z.string().optional(),
+  live: z.boolean().optional()
+});
+var SingleLookupSchema = z.string().min(1);
+var MultiLookupSchema = z.union([
+  z.string().min(1),
+  z.array(z.string().min(1)).min(1).max(16)
+]);
+var FreeResponseSchema = z.object({
+  domain: z.string(),
+  first: z.number(),
+  last: z.number(),
+  groups: z.array(z.object({
+    name: z.string(),
+    live: z.number(),
+    dead: z.number(),
+    latest: z.number(),
+    oldest: z.number(),
+    categories: z.array(z.object({
+      live: z.number(),
+      dead: z.number(),
+      latest: z.number(),
+      oldest: z.number(),
+      name: z.string()
+    }))
+  }))
+});
+var TechnologySchema = z.object({
+  Name: z.string(),
+  Description: z.string(),
+  Link: z.string(),
+  Parent: z.string().optional(),
+  Tag: z.string(),
+  FirstDetected: z.number(),
+  LastDetected: z.number(),
+  IsPremium: z.string(),
+  Categories: z.array(z.string()).optional()
+});
+var PathSchema = z.object({
+  Technologies: z.array(TechnologySchema),
+  FirstIndexed: z.number(),
+  LastIndexed: z.number(),
+  Domain: z.string(),
+  Url: z.string(),
+  SubDomain: z.string()
+});
+var MetaSchema = z.object({
+  Majestic: z.number(),
+  Vertical: z.string(),
+  Social: z.array(z.string()),
+  CompanyName: z.string(),
+  Telephones: z.array(z.string()),
+  Emails: z.array(z.string()),
+  City: z.string(),
+  State: z.string(),
+  Postcode: z.string(),
+  Country: z.string(),
+  Names: z.array(z.object({
+    Name: z.string(),
+    Type: z.number(),
+    Level: z.string(),
+    Email: z.string()
+  })),
+  ARank: z.number(),
+  QRank: z.number()
+});
+var AttributesSchema = z.object({
+  MJRank: z.number(),
+  MJTLDRank: z.number(),
+  RefSN: z.number(),
+  RefIP: z.number(),
+  Sitemap: z.number(),
+  GTMTags: z.number(),
+  QubitTags: z.number(),
+  TealiumTags: z.number(),
+  AdobeTags: z.number(),
+  CDimensions: z.number(),
+  CGoals: z.number(),
+  CMetrics: z.number()
+});
+var DomainResponseSchema = z.object({
+  Results: z.array(z.object({
+    Result: z.object({
+      SpendHistory: z.array(z.object({
+        D: z.number(),
+        S: z.number()
+      })),
+      IsDB: z.string(),
+      Spend: z.number(),
+      Paths: z.array(PathSchema)
+    }),
+    Meta: MetaSchema,
+    Attributes: AttributesSchema,
+    FirstIndexed: z.number(),
+    LastIndexed: z.number(),
+    Lookup: z.string(),
+    SalesRevenue: z.number()
+  })),
+  Errors: z.array(z.string())
+});
+var ListsResponseSchema = z.object({
+  NextOffset: z.string(),
+  Results: z.array(z.object({
+    D: z.string(),
+    FI: z.number().optional(),
+    LI: z.number().optional(),
+    LOS: z.array(z.string()).optional(),
+    Q: z.number().optional(),
+    A: z.number().optional(),
+    U: z.number().optional(),
+    M: z.number().optional(),
+    SKU: z.number().optional(),
+    F: z.number().optional(),
+    E: z.number().optional(),
+    FD: z.number().optional(),
+    LD: z.number().optional(),
+    S: z.number().optional(),
+    R: z.number().optional(),
+    Country: z.string().optional()
+  }))
+});
+var RelationshipsResponseSchema = z.object({
+  Relationships: z.array(z.object({
+    Domain: z.string(),
+    Identifiers: z.array(z.object({
+      Value: z.string(),
+      Type: z.string(),
+      First: z.number(),
+      Last: z.number(),
+      Matches: z.array(z.object({
+        Domain: z.string(),
+        First: z.number(),
+        Last: z.number(),
+        Overlap: z.boolean()
+      }))
+    }))
+  })),
+  Errors: z.array(z.string()),
+  results: z.number(),
+  max_per_page: z.number(),
+  next_skip: z.number(),
+  more_results: z.boolean()
+});
+var KeywordsResponseSchema = z.object({
+  Keywords: z.array(z.object({
+    Domain: z.string(),
+    Keywords: z.array(z.string())
+  }))
+});
+var TrendsResponseSchema = z.object({
+  Tech: z.object({
+    icon: z.string(),
+    categories: z.array(z.string()),
+    tag: z.string(),
+    is_premium: z.string(),
+    name: z.string(),
+    description: z.string(),
+    link: z.string(),
+    trends_link: z.string(),
+    coverage: z.object({
+      ten_k: z.number(),
+      hundred_k: z.number(),
+      milly: z.number(),
+      live: z.number(),
+      expired: z.number()
+    })
+  })
+});
+var CompanyToUrlResponseSchema = z.array(z.object({
+  Domain: z.string(),
+  CompanyName: z.string(),
+  Spend: z.number(),
+  PageRank: z.number(),
+  BuiltWithRank: z.number(),
+  Parked: z.boolean(),
+  Country: z.string(),
+  State: z.string(),
+  Postcode: z.string(),
+  City: z.string(),
+  Socials: z.array(z.string())
+}));
+var TrustResponseSchema = z.object({
+  Domain: z.string(),
+  DBRecord: z.object({
+    EarliestRecord: z.number(),
+    LatestUpdate: z.number(),
+    PremiumTechs: z.number(),
+    LiveTechs: z.boolean(),
+    AffiliateLinks: z.boolean(),
+    PaymentOptions: z.boolean(),
+    Ecommerce: z.boolean(),
+    Parked: z.boolean(),
+    Spend: z.number(),
+    Established: z.boolean(),
+    DBIndexed: z.boolean()
+  }),
+  LiveRecord: z.object({}).passthrough().nullable(),
+  Status: z.number()
+});
+var TagsResponseSchema = z.array(z.object({
+  Value: z.string(),
+  Matches: z.array(z.object({
+    Domain: z.string(),
+    First: z.string(),
+    Last: z.string()
+  }))
+}));
+var RecommendationsResponseSchema = z.array(z.object({
+  Domain: z.string(),
+  Compiled: z.string(),
+  Recommendations: z.array(z.object({
+    link: z.string(),
+    name: z.string(),
+    tag: z.string(),
+    categories: z.array(z.string()),
+    stars: z.number(),
+    match: z.number()
+  }))
+}));
+var RedirectsResponseSchema = z.object({
+  Lookup: z.string(),
+  Inbound: z.array(z.object({
+    Domain: z.string(),
+    FirstDetected: z.string(),
+    LastDetected: z.string()
+  })),
+  Outbound: z.array(z.object({
+    Domain: z.string(),
+    FirstDetected: z.string(),
+    LastDetected: z.string()
+  }))
+});
+var ProductResponseSchema = z.object({
+  query: z.string(),
+  is_more: z.boolean(),
+  page: z.number(),
+  limit: z.number(),
+  results: z.number(),
+  shop_count: z.number(),
+  credits: z.number(),
+  used: z.number(),
+  remaining: z.number(),
+  used_this_query: z.number(),
+  next_page: z.string(),
+  shops: z.array(z.object({
+    Domain: z.string(),
+    Products: z.array(z.object({
+      Title: z.string(),
+      Url: z.string(),
+      Indexed: z.string(),
+      FirstIndexed: z.string(),
+      Price: z.number()
+    })),
+    Type: z.number(),
+    Spend: z.number()
+  }))
+});
+
+// src/params.ts
+var toQueryString = (params) => Object.entries(params).filter((entry) => entry[1] !== undefined).map(([k, v]) => `${k}=${encodeURIComponent(v).replace(/%2C/gi, ",")}`).join("&");
+var booleanFlag = (value) => value ? "yes" : undefined;
+var booleanParams = (params, mapping) => Object.fromEntries(Object.entries(mapping).map(([jsKey, apiKey]) => [
+  apiKey,
+  booleanFlag(params?.[jsKey])
+]));
+var cleanWords = (words) => words ? words.split(",").map((w) => w.trim()).join(",") : undefined;
+var buildURL = (apiKey, format, path, params, subdomain = "api") => {
+  const base = `https://${subdomain}.builtwith.com/${path}/api.${format}?KEY=${apiKey}`;
+  const qs = toQueryString(params);
+  return qs ? `${base}&${qs}` : base;
+};
+var validateLookup = (url, { multi = false } = {}) => {
+  if (multi) {
+    MultiLookupSchema.parse(url);
+  } else {
+    SingleLookupSchema.parse(url);
+  }
+  if (Array.isArray(url)) {
+    if (!multi)
+      throw new Error("API does not allow for multi-domain LOOKUP");
+    if (url.length > 16)
+      throw new Error("Domain LOOKUP size too big (16 max)");
+  }
+};
+
+// src/request.ts
+var TEXT_FORMATS = [
+  VALID_RESPONSE_TYPES.TXT,
+  VALID_RESPONSE_TYPES.XML,
+  VALID_RESPONSE_TYPES.CSV,
+  VALID_RESPONSE_TYPES.TSV
+];
+var request = async (url, format, schema) => {
+  const res = await fetch(url);
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`BuiltWith API error ${res.status}: ${body}`);
+  }
+  if (TEXT_FORMATS.includes(format)) {
+    return res.text();
+  }
+  const data = await res.json();
+  return schema.parse(data);
+};
+var requestSafe = async (url, format, schema) => {
+  const res = await fetch(url);
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`BuiltWith API error ${res.status}: ${body}`);
+  }
+  if (TEXT_FORMATS.includes(format)) {
+    return res.text();
+  }
+  const raw = await res.text();
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    console.warn("BuiltWith sent an invalid JSON payload. Falling back to text parsing.");
+    return raw;
+  }
+  return schema.parse(data);
+};
+
+// src/index.ts
+var DOMAIN_BOOLEANS = {
+  hideAll: "HIDETEXT",
+  hideDescriptionAndLinks: "HIDEDL",
+  onlyLiveTechnologies: "LIVEONLY",
+  noMetaData: "NOMETA",
+  noAttributeData: "NOATTR",
+  noPII: "NOPII"
+};
+function createClient(apiKey, moduleParams = {}) {
+  if (!apiKey) {
+    throw new Error("You must initialize the BuiltWith module with an api key");
+  }
+  const parsed = ClientOptionsSchema.parse(moduleParams);
+  const format = parsed.responseFormat || "json";
+  if (format === VALID_RESPONSE_TYPES.TXT) {
+    console.warn("TXT response format is only supported for the BuiltWith Lists API. See: https://api.builtwith.com/lists-api");
+  }
+  const url = (path, params) => buildURL(apiKey, format, path, params);
+  const get = (bwURL, schema) => request(bwURL, format, schema);
+  const getSafe = (bwURL, schema) => requestSafe(bwURL, format, schema);
+  return {
+    free: async (lookup) => {
+      validateLookup(lookup);
+      return get(url("free1", { LOOKUP: lookup }), FreeResponseSchema);
+    },
+    domain: async (lookup, params) => {
+      validateLookup(lookup, { multi: true });
+      if (params)
+        DomainParamsSchema.parse(params);
+      return get(url("v22", {
+        LOOKUP: Array.isArray(lookup) ? lookup.join(",") : lookup,
+        ...booleanParams(params, DOMAIN_BOOLEANS),
+        FDRANGE: params?.firstDetectedRange,
+        LDRANGE: params?.lastDetectedRange
+      }), DomainResponseSchema);
+    },
+    lists: async (technology, params) => {
+      if (params)
+        ListsParamsSchema.parse(params);
+      return getSafe(url("lists12", {
+        TECH: technology,
+        META: params?.includeMetaData ? "yes" : undefined,
+        OFFSET: params?.offset,
+        SINCE: params?.since
+      }), ListsResponseSchema);
+    },
+    relationships: async (lookup) => {
+      validateLookup(lookup, { multi: true });
+      return get(url("rv4", {
+        LOOKUP: Array.isArray(lookup) ? lookup.join(",") : lookup
+      }), RelationshipsResponseSchema);
+    },
+    keywords: async (lookup) => {
+      validateLookup(lookup, { multi: true });
+      return get(url("kw2", {
+        LOOKUP: Array.isArray(lookup) ? lookup.join(",") : lookup
+      }), KeywordsResponseSchema);
+    },
+    trends: async (technology, params) => {
+      if (params)
+        TrendsParamsSchema.parse(params);
+      return getSafe(url("trends/v6", {
+        TECH: technology,
+        DATE: params?.date
+      }), TrendsResponseSchema);
+    },
+    companyToUrl: async (companyName, params) => {
+      if (params)
+        CompanyToUrlParamsSchema.parse(params);
+      return get(url("ctu3", {
+        COMPANY: companyName,
+        TLD: params?.tld,
+        AMOUNT: params?.amount
+      }), CompanyToUrlResponseSchema);
+    },
+    domainLive: async (lookup) => {
+      validateLookup(lookup);
+      return get(url("ddlv2", { LOOKUP: lookup }), DomainResponseSchema);
+    },
+    trust: async (lookup, params) => {
+      validateLookup(lookup);
+      if (params)
+        TrustParamsSchema.parse(params);
+      return get(url("trustv1", {
+        LOOKUP: lookup,
+        WORDS: cleanWords(params?.words),
+        LIVE: params?.live ? "yes" : undefined
+      }), TrustResponseSchema);
+    },
+    tags: async (lookup) => {
+      validateLookup(lookup);
+      return get(url("tag1", { LOOKUP: lookup }), TagsResponseSchema);
+    },
+    recommendations: async (lookup) => {
+      validateLookup(lookup);
+      return get(url("rec1", { LOOKUP: lookup }), RecommendationsResponseSchema);
+    },
+    redirects: async (lookup) => {
+      validateLookup(lookup);
+      return get(url("redirect1", { LOOKUP: lookup }), RedirectsResponseSchema);
+    },
+    product: async (query) => {
+      return get(url("productv1", { QUERY: query }), ProductResponseSchema);
+    }
+  };
+}
+
+// src/errors.ts
+import { z as z2 } from "zod/v4";
+function formatError(err) {
+  if (err instanceof z2.ZodError) {
+    const fields = err.issues.map((i) => {
+      const path = i.path.length > 0 ? i.path.join(".") : "response";
+      return `  ${path}: ${i.message}`;
+    });
+    return `BuiltWith API returned an unexpected response:
+${fields.join(`
+`)}`;
+  }
+  if (err instanceof Error) {
+    return err.message;
+  }
+  return String(err);
+}
+
+// src/cli.ts
+import { createRequire } from "node:module";
+import { parseArgs } from "node:util";
+
+// src/commands.ts
+function splitLookup(value) {
+  const str = String(value);
+  return str.includes(",") ? str.split(",").map((s) => s.trim()) : str;
+}
+var commands = [
+  {
+    name: "free",
+    description: "Free lookup — basic technology profile for a domain",
+    args: [
+      { name: "lookup", description: "Domain to look up", type: "string", required: true }
+    ],
+    execute: (client, args) => client.free(String(args.lookup))
+  },
+  {
+    name: "domain",
+    description: "Detailed technology profile for one or more domains (comma-separated)",
+    args: [
+      { name: "lookup", description: "Domain(s) to look up (comma-separated for multiple)", type: "string", required: true },
+      { name: "hideAll", description: "Hide description text and links", type: "boolean", required: false },
+      { name: "hideDescriptionAndLinks", description: "Hide description and links only", type: "boolean", required: false },
+      { name: "onlyLiveTechnologies", description: "Only return live technologies", type: "boolean", required: false },
+      { name: "noMetaData", description: "Exclude metadata", type: "boolean", required: false },
+      { name: "noAttributeData", description: "Exclude attribute data", type: "boolean", required: false },
+      { name: "noPII", description: "Exclude personally identifiable information", type: "boolean", required: false },
+      { name: "firstDetectedRange", description: "Filter by first detected date range", type: "string", required: false },
+      { name: "lastDetectedRange", description: "Filter by last detected date range", type: "string", required: false }
+    ],
+    execute: (client, args) => {
+      const lookup = splitLookup(args.lookup);
+      const { lookup: _, ...params } = args;
+      return client.domain(lookup, Object.keys(params).length > 0 ? params : undefined);
+    }
+  },
+  {
+    name: "lists",
+    description: "List domains using a specific technology",
+    args: [
+      { name: "technology", description: "Technology name to search for", type: "string", required: true },
+      { name: "includeMetaData", description: "Include metadata in results", type: "boolean", required: false },
+      { name: "offset", description: "Pagination offset", type: "string", required: false },
+      { name: "since", description: "Only return results since this date", type: "string", required: false }
+    ],
+    execute: (client, args) => {
+      const { technology, ...params } = args;
+      return client.lists(String(technology), Object.keys(params).length > 0 ? params : undefined);
+    }
+  },
+  {
+    name: "relationships",
+    description: "Find related domains via shared identifiers",
+    args: [
+      { name: "lookup", description: "Domain(s) to look up (comma-separated for multiple)", type: "string", required: true }
+    ],
+    execute: (client, args) => client.relationships(splitLookup(args.lookup))
+  },
+  {
+    name: "keywords",
+    description: "Get keywords for one or more domains",
+    args: [
+      { name: "lookup", description: "Domain(s) to look up (comma-separated for multiple)", type: "string", required: true }
+    ],
+    execute: (client, args) => client.keywords(splitLookup(args.lookup))
+  },
+  {
+    name: "trends",
+    description: "Technology adoption trends",
+    args: [
+      { name: "technology", description: "Technology name", type: "string", required: true },
+      { name: "date", description: "Date filter", type: "string", required: false }
+    ],
+    execute: (client, args) => {
+      const { technology, ...params } = args;
+      return client.trends(String(technology), Object.keys(params).length > 0 ? params : undefined);
+    }
+  },
+  {
+    name: "companyToUrl",
+    description: "Find domains associated with a company name",
+    args: [
+      { name: "companyName", description: "Company name to search", type: "string", required: true },
+      { name: "tld", description: "Filter by top-level domain", type: "string", required: false },
+      { name: "amount", description: "Number of results to return", type: "number", required: false }
+    ],
+    execute: (client, args) => {
+      const { companyName, ...params } = args;
+      return client.companyToUrl(String(companyName), Object.keys(params).length > 0 ? params : undefined);
+    }
+  },
+  {
+    name: "domainLive",
+    description: "Live technology lookup for a domain",
+    args: [
+      { name: "lookup", description: "Domain to look up", type: "string", required: true }
+    ],
+    execute: (client, args) => client.domainLive(String(args.lookup))
+  },
+  {
+    name: "trust",
+    description: "Trust/verification score for a domain",
+    args: [
+      { name: "lookup", description: "Domain to look up", type: "string", required: true },
+      { name: "words", description: "Comma-separated keywords to check", type: "string", required: false },
+      { name: "live", description: "Include live analysis", type: "boolean", required: false }
+    ],
+    execute: (client, args) => {
+      const { lookup, ...params } = args;
+      return client.trust(String(lookup), Object.keys(params).length > 0 ? params : undefined);
+    }
+  },
+  {
+    name: "tags",
+    description: "Get tracking/analytics tags for a domain",
+    args: [
+      { name: "lookup", description: "Domain to look up", type: "string", required: true }
+    ],
+    execute: (client, args) => client.tags(String(args.lookup))
+  },
+  {
+    name: "recommendations",
+    description: "Get technology recommendations for a domain",
+    args: [
+      { name: "lookup", description: "Domain to look up", type: "string", required: true }
+    ],
+    execute: (client, args) => client.recommendations(String(args.lookup))
+  },
+  {
+    name: "redirects",
+    description: "Get redirect chains for a domain",
+    args: [
+      { name: "lookup", description: "Domain to look up", type: "string", required: true }
+    ],
+    execute: (client, args) => client.redirects(String(args.lookup))
+  },
+  {
+    name: "product",
+    description: "Search for products across e-commerce sites",
+    args: [
+      { name: "query", description: "Product search query", type: "string", required: true }
+    ],
+    execute: (client, args) => client.product(String(args.query))
+  }
+];
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var USAGE = `Usage: builtwith <command> <primary-arg> [--flag value ...]
+
+Commands:
+${commands.map((c) => `  ${c.name.padEnd(16)} ${c.description}`).join(`
+`)}
+
+Options:
+  --api-key <key>  BuiltWith API key (or set BUILTWITH_API_KEY env var)
+  --version        Show version number
+  --help           Show help
+
+Examples:
+  builtwith free example.com
+  builtwith domain example.com --hideAll --onlyLiveTechnologies
+  builtwith domain "example.com,other.com"
+  builtwith lists Shopify --since 2024-01-01
+  builtwith trust example.com --words "shop,buy" --live
+`;
+function printCommandHelp(cmd) {
+  const primary = cmd.args.find((a) => a.required);
+  const flags = cmd.args.filter((a) => !a.required);
+  console.log(`Usage: builtwith ${cmd.name} <${primary?.name ?? "arg"}>${flags.length ? " [options]" : ""}
+`);
+  console.log(`  ${cmd.description}
+`);
+  if (flags.length) {
+    console.log("Options:");
+    for (const f of flags) {
+      console.log(`  --${f.name.padEnd(28)} ${f.description} (${f.type})`);
+    }
+  }
+}
+function run() {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--version") || argv.includes("-V")) {
+    console.log(version);
+    process.exit(0);
+  }
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+    console.log(USAGE);
+    process.exit(0);
+  }
+  const commandName = argv[0];
+  const cmd = commands.find((c) => c.name === commandName);
+  if (!cmd) {
+    console.error(`Unknown command: ${commandName}
+`);
+    console.log(USAGE);
+    process.exit(1);
+  }
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printCommandHelp(cmd);
+    process.exit(0);
+  }
+  const primaryArg = cmd.args.find((a) => a.required);
+  const primaryValue = argv[1];
+  if (primaryArg && (!primaryValue || primaryValue.startsWith("--"))) {
+    console.error(`Error: missing required argument <${primaryArg.name}>`);
+    process.exit(1);
+  }
+  const flagArgs = cmd.args.filter((a) => !a.required);
+  const options = {
+    "api-key": { type: "string" }
+  };
+  for (const f of flagArgs) {
+    options[f.name] = { type: f.type === "boolean" ? "boolean" : "string" };
+  }
+  const { values } = parseArgs({
+    args: argv.slice(2),
+    options,
+    strict: false
+  });
+  const apiKey = values["api-key"] || process.env.BUILTWITH_API_KEY;
+  if (!apiKey) {
+    console.error("Error: pass --api-key or set BUILTWITH_API_KEY environment variable.");
+    process.exit(1);
+  }
+  const args = {};
+  if (primaryArg) {
+    args[primaryArg.name] = primaryValue;
+  }
+  for (const f of flagArgs) {
+    if (values[f.name] !== undefined) {
+      if (f.type === "number") {
+        args[f.name] = Number(values[f.name]);
+      } else {
+        args[f.name] = values[f.name];
+      }
+    }
+  }
+  const client = createClient(apiKey);
+  cmd.execute(client, args).then((result) => {
+    console.log(JSON.stringify(result, null, 2));
+  }).catch((err) => {
+    console.error(formatError(err));
+    process.exit(1);
+  });
+}
+run();
+
+//# debugId=D76DF713FC3000FE64756E2164756E21