@highlightxyz/cli 0.1.0

package/lib/index.js

@@ -0,0 +1,3694 @@
+#!/usr/bin/env node
+// package.json
+var package_default = {
+  name: "@highlightxyz/cli",
+  version: "0.1.0",
+  description: "Official command-line interface for the Highlight API",
+  keywords: [
+    "cli",
+    "ethereum",
+    "highlight",
+    "nft",
+    "web3"
+  ],
+  homepage: "https://highlight.xyz",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/highlight-xyz/highlight-app.git",
+    directory: "packages/cli"
+  },
+  files: [
+    "lib",
+    "README.md"
+  ],
+  type: "module",
+  bin: {
+    hl: "./lib/index.js"
+  },
+  scripts: {
+    build: "bun build ./src/index.ts --outfile ./lib/index.js --target node --format esm",
+    "ts-check": "bunx --bun tsgo --noEmit -p tsconfig.json",
+    test: "bun test",
+    lint: "oxlint ./src",
+    "lint:fix": "oxlint --fix --quiet ./src",
+    format: 'oxfmt --check --no-error-on-unmatched-pattern "./src/**/*.{js,jsx,ts,tsx,mjs,cjs}"',
+    "format:fix": 'oxfmt --write --no-error-on-unmatched-pattern "./src/**/*.{js,jsx,ts,tsx,mjs,cjs}"',
+    prepublishOnly: "bun run build"
+  },
+  dependencies: {
+    "@highlightxyz/sdk": "*"
+  },
+  devDependencies: {
+    "@types/bun": "^1.3.9",
+    "@types/node": "^25.3.2"
+  },
+  engines: {
+    node: ">=20"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/args.ts
+import { parseArgs } from "node:util";
+
+// src/errors.ts
+class CliError extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var errorMessage = (error) => {
+  if (typeof error === "string" && error.length > 0) {
+    return error;
+  }
+  if (isRecord(error)) {
+    for (const key of ["message", "error", "name"]) {
+      const value = error[key];
+      if (typeof value === "string" && value.length > 0) {
+        return value;
+      }
+    }
+    return JSON.stringify(error);
+  }
+  return "Unknown API error";
+};
+
+class ApiError extends CliError {
+  status;
+  details;
+  constructor(error, status) {
+    super(status ? `Highlight API returned ${status}: ${errorMessage(error)}` : errorMessage(error));
+    this.name = "ApiError";
+    this.status = status;
+    this.details = error;
+  }
+}
+var unwrap = (result) => {
+  if (result.data !== undefined) {
+    return result.data;
+  }
+  throw new ApiError(result.error, result.response?.status);
+};
+var toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+
+// src/args.ts
+var optionValue = (args, index, option) => {
+  const inline = args[index]?.match(new RegExp(`^${option}=(.+)$`))?.[1];
+  if (inline !== undefined) {
+    return [inline, index];
+  }
+  const value = args[index + 1];
+  if (!value || value.startsWith("-")) {
+    throw new CliError(`${option} requires a value`, 2);
+  }
+  return [value, index + 1];
+};
+var extractGlobalOptions = (args) => {
+  const global = {
+    help: false,
+    json: false,
+    version: false
+  };
+  const remaining = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--json") {
+      global.json = true;
+    } else if (argument === "--help" || argument === "-h") {
+      global.help = true;
+    } else if (argument === "--version" || argument === "-v") {
+      global.version = true;
+    } else if (argument === "--profile" || argument.startsWith("--profile=")) {
+      const [value, consumedIndex] = optionValue(args, index, "--profile");
+      global.profile = value;
+      index = consumedIndex;
+    } else if (argument === "--api-url" || argument.startsWith("--api-url=")) {
+      const [value, consumedIndex] = optionValue(args, index, "--api-url");
+      global.apiUrl = value;
+      index = consumedIndex;
+    } else {
+      remaining.push(argument);
+    }
+  }
+  return { args: remaining, global };
+};
+var parseCommandArgs = (args, config) => {
+  try {
+    return parseArgs({
+      allowPositionals: true,
+      args,
+      options: config.options,
+      strict: true
+    });
+  } catch (error) {
+    throw new CliError(toErrorMessage(error), 2);
+  }
+};
+var requiredPositional = (positionals, index, label) => {
+  const value = positionals[index];
+  if (!value) {
+    throw new CliError(`Missing required argument: ${label}`, 2);
+  }
+  return value;
+};
+var assertNoExtraPositionals = (positionals, expected) => {
+  if (positionals.length > expected) {
+    throw new CliError(`Unexpected argument: ${positionals[expected]}`, 2);
+  }
+};
+var positiveInteger = (value, label) => {
+  if (value === undefined)
+    return;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new CliError(`${label} must be a positive integer`, 2);
+  }
+  return parsed;
+};
+var positiveNumber = (value, label) => {
+  if (value === undefined)
+    return;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new CliError(`${label} must be a positive number`, 2);
+  }
+  return parsed;
+};
+
+// ../sdk/src/v1/gen/types.gen.ts
+var CollectionType;
+((CollectionType2) => {
+  CollectionType2["OpenEdition"] = "OpenEdition";
+  CollectionType2["LimitedEdition"] = "LimitedEdition";
+  CollectionType2["OneOfOne"] = "OneOfOne";
+  CollectionType2["Series"] = "Series";
+  CollectionType2["GenerativeSeries"] = "GenerativeSeries";
+})(CollectionType ||= {});
+var ContractStandard;
+((ContractStandard2) => {
+  ContractStandard2["Erc721"] = "ERC721";
+  ContractStandard2["Erc1155"] = "ERC1155";
+})(ContractStandard ||= {});
+var SaleType;
+((SaleType2) => {
+  SaleType2["FixedPrice"] = "FIXED_PRICE";
+  SaleType2["DutchAuction"] = "DUTCH_AUCTION";
+  SaleType2["RankedAuction"] = "RANKED_AUCTION";
+  SaleType2["EnglishAuction"] = "ENGLISH_AUCTION";
+  SaleType2["Custom"] = "CUSTOM";
+})(SaleType ||= {});
+var SaleAccessMode;
+((SaleAccessMode2) => {
+  SaleAccessMode2["Public"] = "PUBLIC";
+  SaleAccessMode2["Gated"] = "GATED";
+})(SaleAccessMode ||= {});
+var GateMatchMode;
+((GateMatchMode2) => {
+  GateMatchMode2["All"] = "ALL";
+  GateMatchMode2["Any"] = "ANY";
+})(GateMatchMode ||= {});
+// ../sdk/src/v1/gen/core/bodySerializer.gen.ts
+var jsonBodySerializer = {
+  bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
+};
+// ../sdk/src/v1/gen/core/params.gen.ts
+var extraPrefixesMap = {
+  $body_: "body",
+  $headers_: "headers",
+  $path_: "path",
+  $query_: "query"
+};
+var extraPrefixes = Object.entries(extraPrefixesMap);
+var buildKeyMap = (fields, map) => {
+  if (!map) {
+    map = new Map;
+  }
+  for (const config of fields) {
+    if ("in" in config) {
+      if (config.key) {
+        map.set(config.key, {
+          in: config.in,
+          map: config.map
+        });
+      }
+    } else if ("key" in config) {
+      map.set(config.key, {
+        map: config.map
+      });
+    } else if (config.args) {
+      buildKeyMap(config.args, map);
+    }
+  }
+  return map;
+};
+var stripEmptySlots = (params) => {
+  for (const [slot, value] of Object.entries(params)) {
+    if (value && typeof value === "object" && !Array.isArray(value) && !Object.keys(value).length) {
+      delete params[slot];
+    }
+  }
+};
+var buildClientParams = (args, fields) => {
+  const params = {
+    body: {},
+    headers: {},
+    path: {},
+    query: {}
+  };
+  const map = buildKeyMap(fields);
+  let config;
+  for (const [index, arg] of args.entries()) {
+    if (fields[index]) {
+      config = fields[index];
+    }
+    if (!config) {
+      continue;
+    }
+    if ("in" in config) {
+      if (config.key) {
+        const field = map.get(config.key);
+        const name = field.map || config.key;
+        if (field.in) {
+          params[field.in][name] = arg;
+        }
+      } else {
+        params.body = arg;
+      }
+    } else {
+      for (const [key, value] of Object.entries(arg ?? {})) {
+        const field = map.get(key);
+        if (field) {
+          if (field.in) {
+            const name = field.map || key;
+            params[field.in][name] = value;
+          } else {
+            params[field.map] = value;
+          }
+        } else {
+          const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix));
+          if (extra) {
+            const [prefix, slot] = extra;
+            params[slot][key.slice(prefix.length)] = value;
+          } else if ("allowExtra" in config && config.allowExtra) {
+            for (const [slot, allowed] of Object.entries(config.allowExtra)) {
+              if (allowed) {
+                params[slot][key] = value;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  stripEmptySlots(params);
+  return params;
+};
+// ../sdk/src/v1/gen/core/serverSentEvents.gen.ts
+var createSseClient = ({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}) => {
+  let lastEventId;
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3000;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted)
+        break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== undefined) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
+        }
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok)
+          throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+        if (!response.body)
+          throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {}
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += value;
+            buffer = buffer.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+            const chunks = buffer.split(`
+
+`);
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split(`
+`);
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join(`
+`);
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 30000);
+        await sleep(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+};
+
+// ../sdk/src/v1/gen/core/pathSerializer.gen.ts
+var separatorArrayExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var separatorArrayNoExplode = (style) => {
+  switch (style) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+};
+var separatorObjectExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value
+}) => {
+  if (!explode) {
+    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      case "simple":
+        return joinedValues2;
+      default:
+        return `${name}=${joinedValues2}`;
+    }
+  }
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value.map((v) => {
+    if (style === "label" || style === "simple") {
+      return allowReserved ? v : encodeURIComponent(v);
+    }
+    return serializePrimitiveParam({
+      allowReserved,
+      name,
+      value: v
+    });
+  }).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+var serializePrimitiveParam = ({
+  allowReserved,
+  name,
+  value
+}) => {
+  if (value === undefined || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+  }
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+var serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+  if (style !== "deepObject" && !explode) {
+    let values = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values = [...values, key, allowReserved ? v : encodeURIComponent(v)];
+    });
+    const joinedValues2 = values.join(",");
+    switch (style) {
+      case "form":
+        return `${name}=${joinedValues2}`;
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      default:
+        return joinedValues2;
+    }
+  }
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+    allowReserved,
+    name: style === "deepObject" ? `${name}[${key}]` : key,
+    value: v
+  })).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+// ../sdk/src/v1/gen/core/utils.gen.ts
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var defaultPathSerializer = ({ path, url: _url }) => {
+  let url = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name = match.substring(1, match.length - 1);
+      let style = "simple";
+      if (name.endsWith("*")) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+      if (name.startsWith(".")) {
+        name = name.substring(1);
+        style = "label";
+      } else if (name.startsWith(";")) {
+        name = name.substring(1);
+        style = "matrix";
+      }
+      const value = path[name];
+      if (value === undefined || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
+        continue;
+      }
+      if (typeof value === "object") {
+        url = url.replace(match, serializeObjectParam({
+          explode,
+          name,
+          style,
+          value,
+          valueOnly: true
+        }));
+        continue;
+      }
+      if (style === "matrix") {
+        url = url.replace(match, `;${serializePrimitiveParam({
+          name,
+          value
+        })}`);
+        continue;
+      }
+      const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+      url = url.replace(match, replaceValue);
+    }
+  }
+  return url;
+};
+var getUrl = ({
+  baseUrl,
+  path,
+  query,
+  querySerializer,
+  url: _url
+}) => {
+  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+  let url = (baseUrl ?? "") + pathUrl;
+  if (path) {
+    url = defaultPathSerializer({ path, url });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url += `?${search}`;
+  }
+  return url;
+};
+function getValidRequestBody(options) {
+  const hasBody = options.body !== undefined;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== undefined && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return;
+}
+
+// ../sdk/src/v1/gen/core/auth.gen.ts
+var getAuthToken = async (auth, callback) => {
+  const token = typeof callback === "function" ? await callback(auth) : callback;
+  if (!token) {
+    return;
+  }
+  if (auth.scheme === "bearer") {
+    return `Bearer ${token}`;
+  }
+  if (auth.scheme === "basic") {
+    return `Basic ${btoa(token)}`;
+  }
+  return token;
+};
+
+// ../sdk/src/v1/gen/client/utils.gen.ts
+var createQuerySerializer = ({
+  parameters = {},
+  ...args
+} = {}) => {
+  const querySerializer = (queryParams) => {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === undefined || value === null) {
+          continue;
+        }
+        const options = parameters[name] || args;
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "form",
+            value,
+            ...options.array
+          });
+          if (serializedArray)
+            search.push(serializedArray);
+        } else if (typeof value === "object") {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "deepObject",
+            value,
+            ...options.object
+          });
+          if (serializedObject)
+            search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name,
+            value
+          });
+          if (serializedPrimitive)
+            search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join("&");
+  };
+  return querySerializer;
+};
+var getParseAs = (contentType) => {
+  if (!contentType) {
+    return "stream";
+  }
+  const cleanContent = contentType.split(";")[0]?.trim();
+  if (!cleanContent) {
+    return;
+  }
+  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+    return "json";
+  }
+  if (cleanContent === "multipart/form-data") {
+    return "formData";
+  }
+  if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
+    return "blob";
+  }
+  if (cleanContent.startsWith("text/")) {
+    return "text";
+  }
+  return;
+};
+var checkForExistence = (options, name) => {
+  if (!name) {
+    return false;
+  }
+  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+    return true;
+  }
+  return false;
+};
+var setAuthParams = async ({
+  security,
+  ...options
+}) => {
+  for (const auth of security) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+    const token = await getAuthToken(auth, options.auth);
+    if (!token) {
+      continue;
+    }
+    const name = auth.name ?? "Authorization";
+    switch (auth.in) {
+      case "query":
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name] = token;
+        break;
+      case "cookie":
+        options.headers.append("Cookie", `${name}=${token}`);
+        break;
+      case "header":
+      default:
+        options.headers.set(name, token);
+        break;
+    }
+  }
+};
+var buildUrl = (options) => getUrl({
+  baseUrl: options.baseUrl,
+  path: options.path,
+  query: options.query,
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+  url: options.url
+});
+var mergeConfigs = (a, b) => {
+  const config = { ...a, ...b };
+  if (config.baseUrl?.endsWith("/")) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a.headers, b.headers);
+  return config;
+};
+var headersEntries = (headers) => {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+};
+var mergeHeaders = (...headers) => {
+  const mergedHeaders = new Headers;
+  for (const header of headers) {
+    if (!header) {
+      continue;
+    }
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v);
+        }
+      } else if (value !== undefined) {
+        mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+      }
+    }
+  }
+  return mergedHeaders;
+};
+
+class Interceptors {
+  fns = [];
+  clear() {
+    this.fns = [];
+  }
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
+    }
+  }
+  exists(id) {
+    const index = this.getInterceptorIndex(id);
+    return Boolean(this.fns[index]);
+  }
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this.fns[id] ? id : -1;
+    }
+    return this.fns.indexOf(id);
+  }
+  update(id, fn) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = fn;
+      return id;
+    }
+    return false;
+  }
+  use(fn) {
+    this.fns.push(fn);
+    return this.fns.length - 1;
+  }
+}
+var createInterceptors = () => ({
+  error: new Interceptors,
+  request: new Interceptors,
+  response: new Interceptors
+});
+var defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: "form"
+  },
+  object: {
+    explode: true,
+    style: "deepObject"
+  }
+});
+var defaultHeaders = {
+  "Content-Type": "application/json"
+};
+var createConfig = (override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: "auto",
+  querySerializer: defaultQuerySerializer,
+  ...override
+});
+
+// ../sdk/src/v1/gen/client/client.gen.ts
+var createClient = (config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
+  const getConfig = () => ({ ..._config });
+  const setConfig = (config2) => {
+    _config = mergeConfigs(_config, config2);
+    return getConfig();
+  };
+  const interceptors = createInterceptors();
+  const beforeRequest = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined
+    };
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security
+      });
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body !== undefined && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.body === undefined || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const url = buildUrl(opts);
+    return { opts, url };
+  };
+  const request = async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    const requestInit = {
+      redirect: "follow",
+      ...opts,
+      body: getValidRequestBody(opts)
+    };
+    let request2 = new Request(url, requestInit);
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        request2 = await fn(request2, opts);
+      }
+    }
+    const _fetch = opts.fetch;
+    let response;
+    try {
+      response = await _fetch(request2);
+    } catch (error2) {
+      let finalError2 = error2;
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError2 = await fn(error2, undefined, request2, opts);
+        }
+      }
+      finalError2 = finalError2 || {};
+      if (opts.throwOnError) {
+        throw finalError2;
+      }
+      return opts.responseStyle === "data" ? undefined : {
+        error: finalError2,
+        request: request2,
+        response: undefined
+      };
+    }
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, request2, opts);
+      }
+    }
+    const result = {
+      request: request2,
+      response
+    };
+    if (response.ok) {
+      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        let emptyData;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "text":
+            emptyData = await response[parseAs]();
+            break;
+          case "formData":
+            emptyData = new FormData;
+            break;
+          case "stream":
+            emptyData = response.body;
+            break;
+          case "json":
+          default:
+            emptyData = {};
+            break;
+        }
+        return opts.responseStyle === "data" ? emptyData : {
+          data: emptyData,
+          ...result
+        };
+      }
+      let data;
+      switch (parseAs) {
+        case "arrayBuffer":
+        case "blob":
+        case "formData":
+        case "text":
+          data = await response[parseAs]();
+          break;
+        case "json": {
+          const text = await response.text();
+          data = text ? JSON.parse(text) : {};
+          break;
+        }
+        case "stream":
+          return opts.responseStyle === "data" ? response.body : {
+            data: response.body,
+            ...result
+          };
+      }
+      if (parseAs === "json") {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+      return opts.responseStyle === "data" ? data : {
+        data,
+        ...result
+      };
+    }
+    const textError = await response.text();
+    let jsonError;
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {}
+    const error = jsonError ?? textError;
+    let finalError = error;
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = await fn(error, response, request2, opts);
+      }
+    }
+    finalError = finalError || {};
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+    return opts.responseStyle === "data" ? undefined : {
+      error: finalError,
+      ...result
+    };
+  };
+  const makeMethodFn = (method) => (options) => request({ ...options, method });
+  const makeSseFn = (method) => async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      headers: opts.headers,
+      method,
+      onRequest: async (url2, init) => {
+        let request2 = new Request(url2, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request2 = await fn(request2, opts);
+          }
+        }
+        return request2;
+      },
+      serializedBody: getValidRequestBody(opts),
+      url
+    });
+  };
+  return {
+    buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE")
+    },
+    trace: makeMethodFn("TRACE")
+  };
+};
+// ../sdk/src/v1/gen/client.gen.ts
+var client = createClient(createConfig());
+
+// ../sdk/src/v1/gen/sdk.gen.ts
+class HeyApiClient {
+  client;
+  constructor(args) {
+    this.client = args?.client ?? client;
+  }
+}
+
+class HeyApiRegistry {
+  defaultKey = "default";
+  instances = new Map;
+  get(key) {
+    const instance = this.instances.get(key ?? this.defaultKey);
+    if (!instance) {
+      throw new Error(`No SDK client found. Create one with "new HighlightClient()" to fix this error.`);
+    }
+    return instance;
+  }
+  set(value, key) {
+    this.instances.set(key ?? this.defaultKey, value);
+  }
+}
+
+class Collection extends HeyApiClient {
+  list(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "page" },
+          { in: "query", key: "limit" },
+          { in: "query", key: "sortBy" },
+          { in: "query", key: "sortDirection" },
+          { in: "query", key: "status" },
+          { in: "query", key: "blockchains" },
+          { in: "query", key: "testnet" },
+          { in: "query", key: "types" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/collection",
+      ...options,
+      ...params
+    });
+  }
+  create(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "body", key: "name" },
+          { in: "body", key: "description" },
+          { in: "body", key: "contractId" },
+          { in: "body", key: "contract" },
+          { in: "body", key: "logoMediaId" },
+          { in: "body", key: "image" },
+          { in: "body", key: "type" },
+          { in: "body", key: "royalty" },
+          { in: "body", key: "tokenManager" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/collection",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  trending(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "window" },
+          { in: "query", key: "chainId" },
+          { in: "query", key: "limit" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/trending",
+      ...options,
+      ...params
+    });
+  }
+  featured(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "limit" },
+          { in: "query", key: "cursor" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/featured",
+      ...options,
+      ...params
+    });
+  }
+  get(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "highlightId" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}",
+      ...options,
+      ...params
+    });
+  }
+  listPreviews(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "query", key: "limit" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}/previews",
+      ...options,
+      ...params
+    });
+  }
+  finalizeBaseUri(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "highlightId" }] }]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/finalize-base-uri",
+      ...options,
+      ...params
+    });
+  }
+  updateGenerativeDetails(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "generative" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).patch({
+      url: "/collection/{highlightId}/details/generative",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  updateSeriesDetails(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "series" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).patch({
+      url: "/collection/{highlightId}/details/series",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  updateEditionDetails(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "edition" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).patch({
+      url: "/collection/{highlightId}/details/edition",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  getSales(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "highlightId" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}/sales",
+      ...options,
+      ...params
+    });
+  }
+  addSale(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "name" },
+          { in: "body", key: "type" },
+          { in: "body", key: "startAt" },
+          { in: "body", key: "endAt" },
+          { in: "body", key: "price" },
+          { in: "body", key: "currency" },
+          { in: "body", key: "maxPerTransaction" },
+          { in: "body", key: "maxPerWallet" },
+          { in: "body", key: "maxTotal" },
+          { in: "body", key: "paymentRecipient" },
+          { in: "body", key: "accessMode" },
+          { in: "body", key: "gateId" },
+          { in: "body", key: "gasSponsored" },
+          { in: "body", key: "mechanicId" },
+          { in: "body", key: "typeConfig" },
+          { in: "body", key: "collectorMessage" },
+          { in: "body", key: "customMintFee" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/sales",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  deleteSale(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "path", key: "saleId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).delete({
+      url: "/collection/{highlightId}/sales/{saleId}",
+      ...options,
+      ...params
+    });
+  }
+  updateSale(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "path", key: "saleId" },
+          { in: "body", key: "name" },
+          { in: "body", key: "startAt" },
+          { in: "body", key: "endAt" },
+          { in: "body", key: "price" },
+          { in: "body", key: "currency" },
+          { in: "body", key: "maxPerTransaction" },
+          { in: "body", key: "maxPerWallet" },
+          { in: "body", key: "maxTotal" },
+          { in: "body", key: "paymentRecipient" },
+          { in: "body", key: "paused" },
+          { in: "body", key: "collectorMessage" },
+          { in: "body", key: "customMintFee" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).patch({
+      url: "/collection/{highlightId}/sales/{saleId}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  claimSale(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "saleId" },
+          { in: "body", key: "amount" },
+          { in: "body", key: "tokenIds" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/sales/claim",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  bidSale(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "saleId" },
+          { in: "body", key: "bidAmount" },
+          { in: "body", key: "bidId" },
+          { in: "body", key: "preferredNftRecipient" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/sales/bid",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  reclaimBid(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "saleId" },
+          { in: "body", key: "bidId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/sales/reclaim",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  claimAuctionEarnings(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "saleId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/sales/earnings",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  rankedAuctionStandings(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "path", key: "saleId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}/sales/{saleId}/standings",
+      ...options,
+      ...params
+    });
+  }
+  fulfillEnglishAuction(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "saleId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/sales/auction/fulfill",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  cancelEnglishAuction(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "saleId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/sales/auction/cancel",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  englishAuctionStanding(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "path", key: "saleId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}/sales/{saleId}/auction",
+      ...options,
+      ...params
+    });
+  }
+  englishAuctionBids(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "path", key: "saleId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}/sales/{saleId}/auction/bids",
+      ...options,
+      ...params
+    });
+  }
+  deploy(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "highlightId" }] }]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/deploy",
+      ...options,
+      ...params
+    });
+  }
+  deployStatus(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "highlightId" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}/deploy/status",
+      ...options,
+      ...params
+    });
+  }
+  deployCancel(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "highlightId" }] }]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/deploy/cancel",
+      ...options,
+      ...params
+    });
+  }
+}
+
+class Token extends HeyApiClient {
+  list(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "query", key: "page" },
+          { in: "query", key: "limit" },
+          { in: "query", key: "sort" },
+          { in: "query", key: "order" },
+          { in: "query", key: "ownerAddress" },
+          { in: "query", key: "search" },
+          { in: "query", key: "attributes" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}/tokens",
+      ...options,
+      ...params
+    });
+  }
+  attributeFacets(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "highlightId" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}/tokens/attributes",
+      ...options,
+      ...params
+    });
+  }
+  get(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "path", key: "tokenId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}/tokens/{tokenId}",
+      ...options,
+      ...params
+    });
+  }
+  listOwners(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "path", key: "tokenId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}/tokens/{tokenId}/owners",
+      ...options,
+      ...params
+    });
+  }
+  redriveReveals(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "highlightId" }] }]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/tokens/redrive-reveals",
+      ...options,
+      ...params
+    });
+  }
+}
+
+class Config extends HeyApiClient {
+  chains(options) {
+    return (options?.client ?? this.client).get({
+      url: "/config/chains",
+      ...options
+    });
+  }
+  systemContract(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "chainId" },
+          { in: "query", key: "type" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/config/system-contract",
+      ...options,
+      ...params
+    });
+  }
+}
+
+class Contract extends HeyApiClient {
+  list(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "limit" },
+          { in: "query", key: "cursor" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/contract",
+      ...options,
+      ...params
+    });
+  }
+  get(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "contractId" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/contract/{contractId}",
+      ...options,
+      ...params
+    });
+  }
+}
+
+class Gate extends HeyApiClient {
+  list(options) {
+    return (options?.client ?? this.client).get({
+      url: "/gate",
+      ...options
+    });
+  }
+  create(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "body", key: "name" },
+          { in: "body", key: "matchMode" },
+          { in: "body", key: "conditions" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/gate",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  remove(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "gateId" }] }]);
+    return (options?.client ?? this.client).delete({
+      url: "/gate/{gateId}",
+      ...options,
+      ...params
+    });
+  }
+  get(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "gateId" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/gate/{gateId}",
+      ...options,
+      ...params
+    });
+  }
+  update(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "gateId" },
+          { in: "body", key: "name" },
+          { in: "body", key: "matchMode" },
+          { in: "body", key: "conditions" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).patch({
+      url: "/gate/{gateId}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  previewCollection(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "chainId" },
+          { in: "path", key: "address" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/gate/preview/collection/{chainId}/{address}",
+      ...options,
+      ...params
+    });
+  }
+  previewAttributes(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "chainId" },
+          { in: "path", key: "address" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/gate/preview/collection/{chainId}/{address}/attributes",
+      ...options,
+      ...params
+    });
+  }
+  previewTokens(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "chainId" },
+          { in: "path", key: "address" },
+          { in: "query", key: "cursor" },
+          { in: "query", key: "limit" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/gate/preview/collection/{chainId}/{address}/tokens",
+      ...options,
+      ...params
+    });
+  }
+  previewToken(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "chainId" },
+          { in: "path", key: "address" },
+          { in: "path", key: "tokenId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/gate/preview/collection/{chainId}/{address}/token/{tokenId}",
+      ...options,
+      ...params
+    });
+  }
+  previewCurrency(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "chainId" },
+          { in: "query", key: "contractAddress" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/gate/preview/currency/{chainId}",
+      ...options,
+      ...params
+    });
+  }
+  previewFarcaster(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "query" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/gate/preview/farcaster/user",
+      ...options,
+      ...params
+    });
+  }
+}
+
+class Mechanic extends HeyApiClient {
+  list(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "builtIn" },
+          { in: "query", key: "type" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/mechanic",
+      ...options,
+      ...params
+    });
+  }
+  create(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "body", key: "slug" },
+          { in: "body", key: "name" },
+          { in: "body", key: "description" },
+          { in: "body", key: "configSchema" },
+          { in: "body", key: "encodingAbi" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/mechanic",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  get(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "mechanicId" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/mechanic/{mechanicId}",
+      ...options,
+      ...params
+    });
+  }
+  update(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "mechanicId" },
+          { in: "body", key: "name" },
+          { in: "body", key: "description" },
+          { in: "body", key: "configSchema" },
+          { in: "body", key: "encodingAbi" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).patch({
+      url: "/mechanic/{mechanicId}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  removeDeployment(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "mechanicId" },
+          { in: "body", key: "chainId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).delete({
+      url: "/mechanic/{mechanicId}/deployment",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  addDeployment(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "mechanicId" },
+          { in: "body", key: "chainId" },
+          { in: "body", key: "address" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/mechanic/{mechanicId}/deployment",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+}
+
+class Media extends HeyApiClient {
+  createUploadSession(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "body", key: "kind" },
+          { in: "body", key: "scope" },
+          { in: "body", key: "fileName" },
+          { in: "body", key: "mimeType" },
+          { in: "body", key: "fileSize" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/media/upload-session",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  upload(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "mediaId" }] }]);
+    return (options?.client ?? this.client).put({
+      url: "/media/{mediaId}/upload",
+      ...options,
+      ...params
+    });
+  }
+  process(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "mediaId" }] }]);
+    return (options?.client ?? this.client).post({
+      url: "/media/{mediaId}/process",
+      ...options,
+      ...params
+    });
+  }
+  listChildren(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "mediaId" },
+          { in: "query", key: "cursor" },
+          { in: "query", key: "limit" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/media/{mediaId}/children",
+      ...options,
+      ...params
+    });
+  }
+  delete(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "mediaId" }] }]);
+    return (options?.client ?? this.client).delete({
+      url: "/media/{mediaId}",
+      ...options,
+      ...params
+    });
+  }
+  get(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "mediaId" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/media/{mediaId}",
+      ...options,
+      ...params
+    });
+  }
+  publish(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "mediaId" }] }]);
+    return (options?.client ?? this.client).post({
+      url: "/media/{mediaId}/publish",
+      ...options,
+      ...params
+    });
+  }
+  getChild(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "mediaId" },
+          { in: "path", key: "path" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/media/{mediaId}/children/{path}",
+      ...options,
+      ...params
+    });
+  }
+}
+
+class Tx extends HeyApiClient {
+  status(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "chainId" },
+          { in: "path", key: "txHash" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/tx/{chainId}/{txHash}",
+      ...options,
+      ...params
+    });
+  }
+  submit(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "chainId" },
+          { in: "path", key: "txHash" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/tx/{chainId}/{txHash}",
+      ...options,
+      ...params
+    });
+  }
+}
+
+class Siwe extends HeyApiClient {
+  nonce(options) {
+    return (options?.client ?? this.client).post({ url: "/user/signin/siwe/nonce", ...options });
+  }
+}
+
+class User extends HeyApiClient {
+  signin(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ key: "body", map: "body" }] }]);
+    return (options?.client ?? this.client).post({
+      url: "/user/signin",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  _siwe;
+  get siwe() {
+    return this._siwe ??= new Siwe({ client: this.client });
+  }
+}
+
+class ApiKey extends HeyApiClient {
+  list(options) {
+    return (options?.client ?? this.client).get({ url: "/user/api-keys", ...options });
+  }
+  create(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "body", key: "name" },
+          { in: "body", key: "expiresAt" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/user/api-keys",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  revoke(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "apiKeyId" }] }]);
+    return (options?.client ?? this.client).delete({
+      url: "/user/api-keys/{apiKeyId}",
+      ...options,
+      ...params
+    });
+  }
+}
+
+class Health extends HeyApiClient {
+  get(options) {
+    return (options?.client ?? this.client).get({
+      url: "/health",
+      ...options
+    });
+  }
+}
+
+class HighlightClient extends HeyApiClient {
+  static __registry = new HeyApiRegistry;
+  constructor(args) {
+    super(args);
+    HighlightClient.__registry.set(this, args?.key);
+  }
+  postIndexerChainsByChainIdActivate(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "chainId" }] }]);
+    return (options?.client ?? this.client).post({
+      url: "/indexer/chains/{chainId}/activate",
+      ...options,
+      ...params
+    });
+  }
+  postIndexerChainsByChainIdReset(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "chainId" },
+          { in: "body", key: "blockNumber" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/indexer/chains/{chainId}/reset",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  postIndexerChainsByChainIdPoll(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "chainId" }] }]);
+    return (options?.client ?? this.client).post({
+      url: "/indexer/chains/{chainId}/poll",
+      ...options,
+      ...params
+    });
+  }
+  _collection;
+  get collection() {
+    return this._collection ??= new Collection({ client: this.client });
+  }
+  _token;
+  get token() {
+    return this._token ??= new Token({ client: this.client });
+  }
+  _config;
+  get config() {
+    return this._config ??= new Config({ client: this.client });
+  }
+  _contract;
+  get contract() {
+    return this._contract ??= new Contract({ client: this.client });
+  }
+  _gate;
+  get gate() {
+    return this._gate ??= new Gate({ client: this.client });
+  }
+  _mechanic;
+  get mechanic() {
+    return this._mechanic ??= new Mechanic({ client: this.client });
+  }
+  _media;
+  get media() {
+    return this._media ??= new Media({ client: this.client });
+  }
+  _tx;
+  get tx() {
+    return this._tx ??= new Tx({ client: this.client });
+  }
+  _user;
+  get user() {
+    return this._user ??= new User({ client: this.client });
+  }
+  _apiKey;
+  get apiKey() {
+    return this._apiKey ??= new ApiKey({ client: this.client });
+  }
+  _health;
+  get health() {
+    return this._health ??= new Health({ client: this.client });
+  }
+}
+
+// ../sdk/src/client.ts
+function createHighlightClient(config) {
+  const resolvedConfig = {
+    ...config,
+    auth: config?.auth ?? config?.apiKey,
+    security: config?.security ?? (config?.auth || config?.apiKey ? [{ type: "http", scheme: "bearer" }] : undefined)
+  };
+  const client2 = createClient(resolvedConfig);
+  return new HighlightClient({ client: client2 });
+}
+// ../sdk/src/v1/media.ts
+var DEFAULT_PREFERENCE = [
+  "Archive" /* Archive */,
+  "Origin" /* Origin */,
+  "Mirror" /* Mirror */
+];
+var pickLocation = (media, preference) => {
+  for (const role of preference) {
+    const location = media.locations.find((l) => l.role === role && l.status === "Succeeded" /* Succeeded */ && l.url !== null);
+    if (location)
+      return location;
+  }
+  return null;
+};
+var resolveMediaUrl = (media, options) => {
+  if (!media)
+    return null;
+  const preference = options?.prefer ? Array.isArray(options.prefer) ? options.prefer : [options.prefer] : DEFAULT_PREFERENCE;
+  return pickLocation(media, preference)?.url ?? null;
+};
+// src/config.ts
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+var DEFAULT_API_URL = "https://api.highlightv2.xyz";
+var CONFIG_VERSION = 1;
+var defaultConfig = () => ({
+  currentProfile: "default",
+  profiles: {},
+  version: CONFIG_VERSION
+});
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isProfile = (value) => {
+  if (!isRecord2(value))
+    return false;
+  return (value.apiKey === undefined || typeof value.apiKey === "string") && (value.apiUrl === undefined || typeof value.apiUrl === "string");
+};
+var parseConfig = (value, configPath) => {
+  if (!isRecord2(value) || value.version !== CONFIG_VERSION || typeof value.currentProfile !== "string" || !isRecord2(value.profiles)) {
+    throw new CliError(`Invalid Highlight CLI config at ${configPath}. Move it aside and run "hl auth login" again.`);
+  }
+  const profiles = {};
+  for (const [name, profile] of Object.entries(value.profiles)) {
+    if (!isProfile(profile)) {
+      throw new CliError(`Invalid Highlight CLI config at ${configPath}. Move it aside and run "hl auth login" again.`);
+    }
+    profiles[name] = profile;
+  }
+  return {
+    currentProfile: value.currentProfile,
+    profiles,
+    version: CONFIG_VERSION
+  };
+};
+var isFileNotFound = (error) => isRecord2(error) && ("code" in error) && error.code === "ENOENT";
+var configPathFor = (runtime) => {
+  const explicitDirectory = runtime.env.HIGHLIGHT_CONFIG_DIR;
+  if (explicitDirectory) {
+    return path.join(explicitDirectory, "config.json");
+  }
+  if (process.platform === "win32" && runtime.env.APPDATA) {
+    return path.join(runtime.env.APPDATA, "Highlight", "config.json");
+  }
+  const configHome = runtime.env.XDG_CONFIG_HOME ?? path.join(runtime.homeDir, ".config");
+  return path.join(configHome, "highlight", "config.json");
+};
+var loadConfig = async (runtime) => {
+  const configPath = configPathFor(runtime);
+  try {
+    const contents = await readFile(configPath, "utf8");
+    let parsed;
+    try {
+      parsed = JSON.parse(contents);
+    } catch {
+      throw new CliError(`Highlight CLI config is not valid JSON: ${configPath}`);
+    }
+    return parseConfig(parsed, configPath);
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return defaultConfig();
+    }
+    throw error;
+  }
+};
+var saveConfig = async (runtime, config) => {
+  const configPath = configPathFor(runtime);
+  const directory = path.dirname(configPath);
+  const temporaryPath = `${configPath}.${process.pid}.tmp`;
+  await mkdir(directory, { mode: 448, recursive: true });
+  await writeFile(temporaryPath, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  await rename(temporaryPath, configPath);
+  await chmod(configPath, 384);
+};
+var profileNameFor = (config, requested) => requested ?? config.currentProfile;
+var profileFor = (config, profileName) => config.profiles[profileName] ?? {};
+var updateProfile = (config, profileName, update) => ({
+  ...config,
+  currentProfile: profileName,
+  profiles: {
+    ...config.profiles,
+    [profileName]: {
+      ...profileFor(config, profileName),
+      ...update
+    }
+  }
+});
+var clearProfileKey = (config, profileName) => {
+  const profile = profileFor(config, profileName);
+  const { apiKey: _apiKey, ...profileWithoutKey } = profile;
+  return {
+    ...config,
+    profiles: {
+      ...config.profiles,
+      [profileName]: profileWithoutKey
+    }
+  };
+};
+
+// src/output.ts
+var cell = (value) => value === null || value === undefined || value === "" ? "—" : String(value);
+var printJson = (runtime, value) => {
+  runtime.stdout(JSON.stringify(value, null, 2));
+};
+var printTable = (runtime, headers, rows) => {
+  const stringRows = rows.map((row) => row.map(cell));
+  const widths = headers.map((header, index) => Math.max(header.length, ...stringRows.map((row) => row[index]?.length ?? 0)));
+  const render = (row) => row.map((value, index) => value.padEnd(widths[index] ?? value.length)).join("  ").trimEnd();
+  runtime.stdout(render(headers));
+  runtime.stdout(render(widths.map((width) => "-".repeat(width))));
+  for (const row of stringRows) {
+    runtime.stdout(render(row));
+  }
+};
+var printCollectionList = (runtime, result) => {
+  printTable(runtime, ["ID", "NAME", "TYPE", "STATUS", "CHAIN", "CONTRACT"], result.items.map((collection) => [
+    collection.highlightId,
+    collection.name,
+    collection.type,
+    collection.status,
+    collection.contract.chainId,
+    collection.contract.address
+  ]));
+  runtime.stdout(`Page ${result.pageInfo.page}/${Math.max(result.pageInfo.totalPages, 1)} · ${result.pageInfo.totalCount} total`);
+};
+var printCollection = (runtime, collection) => {
+  runtime.stdout(`${collection.name} (${collection.highlightId})`);
+  runtime.stdout(`Type: ${collection.type}`);
+  runtime.stdout(`Status: ${collection.status}`);
+  runtime.stdout(`Chain: ${collection.contract.chainId}`);
+  runtime.stdout(`Contract: ${collection.contract.address ?? "not deployed"}`);
+  if (collection.description)
+    runtime.stdout(`Description: ${collection.description}`);
+};
+var printDeployStatus = (runtime, status) => {
+  runtime.stdout(`Deployment ${status.deploymentId}: ${status.status}`);
+  runtime.stdout(`Current step: ${status.currentStep}`);
+  if (status.txHash)
+    runtime.stdout(`Transaction: ${status.txHash}`);
+  if (status.error)
+    runtime.stdout(`Error: ${status.error}`);
+  if (status.currentStep === "AwaitTransaction" && status.contractConfig) {
+    runtime.stdout("Wallet signature required. Transaction payload:");
+    runtime.stdout(JSON.stringify(status.contractConfig, null, 2));
+  }
+};
+var printMedia = (runtime, media2, resolvedUrl) => {
+  runtime.stdout(`Media ${media2.id}: ${media2.status}`);
+  runtime.stdout(`File: ${media2.fileName}`);
+  runtime.stdout(`Kind: ${media2.kind}`);
+  if (resolvedUrl)
+    runtime.stdout(`URL: ${resolvedUrl}`);
+};
+
+// src/sdk.ts
+var createPublicClientContext = async (runtime, global) => {
+  const config = await loadConfig(runtime);
+  const profileName = profileNameFor(config, global.profile);
+  const profile = profileFor(config, profileName);
+  const environmentKey = runtime.env.HIGHLIGHT_API_KEY;
+  const apiKey = environmentKey ?? profile.apiKey;
+  const apiUrl = global.apiUrl ?? runtime.env.HIGHLIGHT_API_URL ?? profile.apiUrl ?? DEFAULT_API_URL;
+  const client3 = createHighlightClient({
+    apiKey,
+    baseUrl: apiUrl,
+    fetch: runtime.fetch
+  });
+  return {
+    apiKey,
+    apiUrl,
+    client: client3,
+    config,
+    credentialSource: apiKey ? environmentKey ? "environment" : "profile" : undefined,
+    profileName
+  };
+};
+var createClientContext = async (runtime, global) => {
+  const context = await createPublicClientContext(runtime, global);
+  if (!context.apiKey || !context.credentialSource) {
+    throw new CliError(`Not authenticated for profile "${context.profileName}". Run "hl auth login" or set HIGHLIGHT_API_KEY.`);
+  }
+  return {
+    ...context,
+    apiKey: context.apiKey,
+    credentialSource: context.credentialSource
+  };
+};
+
+// src/commands/auth.ts
+var validateApiUrl = (value) => {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new CliError(`Invalid API URL: ${value}`, 2);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new CliError("API URL must use http or https", 2);
+  }
+  return url.toString().replace(/\/$/, "");
+};
+var login = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      "api-key": { type: "string" },
+      "api-key-stdin": { type: "boolean" }
+    }
+  });
+  assertNoExtraPositionals(parsed.positionals, 0);
+  if (parsed.values["api-key"] && parsed.values["api-key-stdin"]) {
+    throw new CliError("Use either --api-key or --api-key-stdin, not both", 2);
+  }
+  let apiKey = parsed.values["api-key"] ?? runtime.env.HIGHLIGHT_API_KEY;
+  if (parsed.values["api-key-stdin"]) {
+    apiKey = (await runtime.readStdin()).trim();
+  } else if (!apiKey) {
+    apiKey = (await runtime.promptSecret("Highlight API key: ")).trim();
+  }
+  if (!apiKey) {
+    throw new CliError("An API key is required", 2);
+  }
+  if (!apiKey.startsWith("hl_live_")) {
+    throw new CliError('Highlight API keys must start with "hl_live_"', 2);
+  }
+  const config = await loadConfig(runtime);
+  const profileName = profileNameFor(config, global.profile);
+  const profile = profileFor(config, profileName);
+  const apiUrl = validateApiUrl(global.apiUrl ?? runtime.env.HIGHLIGHT_API_URL ?? profile.apiUrl ?? DEFAULT_API_URL);
+  const client3 = createHighlightClient({
+    apiKey,
+    baseUrl: apiUrl,
+    fetch: runtime.fetch
+  });
+  const keys = unwrap(await client3.apiKey.list());
+  const activeKey = keys.find((key) => key.last4 === apiKey.slice(-4) && !key.revokedAt);
+  await saveConfig(runtime, updateProfile(config, profileName, { apiKey, apiUrl }));
+  const result = {
+    apiKey: activeKey ? {
+      expiresAt: activeKey.expiresAt,
+      id: activeKey.id,
+      last4: activeKey.last4,
+      name: activeKey.name
+    } : { last4: apiKey.slice(-4) },
+    apiUrl,
+    authenticated: true,
+    profile: profileName
+  };
+  if (global.json) {
+    printJson(runtime, result);
+  } else {
+    runtime.stdout(`Authenticated profile "${profileName}" with API key …${apiKey.slice(-4)}.`);
+    runtime.stdout(`API: ${apiUrl}`);
+  }
+};
+var status = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  assertNoExtraPositionals(parsed.positionals, 0);
+  const context = await createClientContext(runtime, global);
+  const keys = unwrap(await context.client.apiKey.list());
+  const activeKey = keys.find((key) => key.last4 === context.apiKey.slice(-4) && key.revokedAt === null);
+  const result = {
+    apiKey: activeKey ? {
+      expiresAt: activeKey.expiresAt,
+      id: activeKey.id,
+      last4: activeKey.last4,
+      name: activeKey.name
+    } : { last4: context.apiKey.slice(-4) },
+    apiUrl: context.apiUrl,
+    authenticated: true,
+    credentialSource: context.credentialSource,
+    profile: context.profileName
+  };
+  if (global.json) {
+    printJson(runtime, result);
+  } else {
+    runtime.stdout(`Authenticated profile "${context.profileName}" with ${context.credentialSource} API key …${context.apiKey.slice(-4)}.`);
+    runtime.stdout(`API: ${context.apiUrl}`);
+  }
+};
+var logout = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  assertNoExtraPositionals(parsed.positionals, 0);
+  const config = await loadConfig(runtime);
+  const profileName = profileNameFor(config, global.profile);
+  const hadStoredKey = Boolean(profileFor(config, profileName).apiKey);
+  await saveConfig(runtime, clearProfileKey(config, profileName));
+  const result = {
+    authenticated: Boolean(runtime.env.HIGHLIGHT_API_KEY),
+    environmentOverride: Boolean(runtime.env.HIGHLIGHT_API_KEY),
+    profile: profileName,
+    removed: hadStoredKey
+  };
+  if (global.json) {
+    printJson(runtime, result);
+  } else if (runtime.env.HIGHLIGHT_API_KEY) {
+    runtime.stdout(`Removed the stored key for profile "${profileName}". HIGHLIGHT_API_KEY is still set in this environment.`);
+  } else if (hadStoredKey) {
+    runtime.stdout(`Logged out profile "${profileName}".`);
+  } else {
+    runtime.stdout(`Profile "${profileName}" had no stored API key.`);
+  }
+};
+
+// src/commands/chains.ts
+var SYSTEM_CONTRACT_TYPES = [
+  "CollectionFactory",
+  "MintManager",
+  "AuctionManager",
+  "PermissionsRegistry",
+  "EditionsMetadataRenderer",
+  "NonTransferableTokenManager",
+  "ConsensualNonTransferableTokenManager",
+  "ConsensualNonTransferableTokenManager2",
+  "GenerativeSeriesImplementation",
+  "SeriesImplementation",
+  "MultipleEditionsImplementation",
+  "MultipleEditionsDFSImplementation",
+  "SingleEditionImplementation",
+  "SingleEditionDFSImplementation",
+  "MinimalForwarder",
+  "Observability",
+  "RandomSeriesImplementation",
+  "MintFeeOracle",
+  "GengineObservability",
+  "ReferralManager",
+  "RazorWorksImplementation",
+  "EditionsDFS1155Implementation",
+  "ObservabilityV2",
+  "BitstreamSeedManager"
+];
+var list = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      mainnet: { type: "boolean" },
+      testnet: { type: "boolean" }
+    }
+  });
+  assertNoExtraPositionals(parsed.positionals, 0);
+  if (parsed.values.mainnet && parsed.values.testnet) {
+    throw new CliError("Use either --mainnet or --testnet, not both", 2);
+  }
+  const context = await createPublicClientContext(runtime, global);
+  const result = unwrap(await context.client.config.chains());
+  const chains = result.chains.filter((chain) => (!parsed.values.mainnet || !chain.testnet) && (!parsed.values.testnet || chain.testnet));
+  if (global.json) {
+    printJson(runtime, { chains });
+    return;
+  }
+  printTable(runtime, ["CHAIN", "NAME", "NETWORK", "TESTNET", "MINT FEE", "CURRENCIES"], chains.map((chain) => [
+    chain.chainId,
+    chain.name,
+    chain.network,
+    chain.testnet ? "yes" : "no",
+    chain.mintFee,
+    chain.supportedCurrencies.map((currency) => currency.symbol).join(", ")
+  ]));
+};
+var systemContract = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const chainIdValue = requiredPositional(parsed.positionals, 0, "chain-id");
+  const typeValue = requiredPositional(parsed.positionals, 1, "contract-type");
+  assertNoExtraPositionals(parsed.positionals, 2);
+  const chainId = positiveInteger(chainIdValue, "chain-id");
+  if (!chainId)
+    throw new CliError("chain-id is required", 2);
+  if (!SYSTEM_CONTRACT_TYPES.includes(typeValue)) {
+    throw new CliError(`Unknown system contract type: ${typeValue}`, 2);
+  }
+  const context = await createPublicClientContext(runtime, global);
+  const result = unwrap(await context.client.config.systemContract({
+    chainId,
+    type: typeValue
+  }));
+  if (global.json)
+    printJson(runtime, result);
+  else
+    runtime.stdout(`${result.type} on ${result.chainId}: ${result.address}`);
+};
+
+// src/json-input.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import path2 from "node:path";
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isOptionalString = (value) => value === undefined || typeof value === "string";
+var isOptionalNullableString = (value) => value === undefined || value === null || typeof value === "string";
+var readJsonInput = async (inputPath, runtime) => {
+  const contents = inputPath === "-" ? await runtime.readStdin() : await readFile2(path2.resolve(runtime.cwd, inputPath), "utf8");
+  try {
+    return JSON.parse(contents);
+  } catch {
+    throw new CliError(`Input is not valid JSON: ${inputPath}`, 2);
+  }
+};
+var readTypedJsonInput = async (inputPath, runtime, validator, expected) => {
+  const value = await readJsonInput(inputPath, runtime);
+  if (!validator(value)) {
+    throw new CliError(`Input must be ${expected}.`, 2);
+  }
+  return value;
+};
+var requiredInputPath = (inputPath) => {
+  if (!inputPath) {
+    throw new CliError('Missing required option: --input <path> (use "-" for stdin)', 2);
+  }
+  return inputPath;
+};
+
+// src/commands/collections.ts
+var isCollectionCreateInput = (value) => {
+  if (!isRecord3(value))
+    return false;
+  if (typeof value.name !== "string" || typeof value.description !== "string" || typeof value.logoMediaId !== "string" || typeof value.image !== "string" || !Object.values(CollectionType).includes(value.type) || !isOptionalString(value.contractId) || !isOptionalString(value.tokenManager)) {
+    return false;
+  }
+  if (value.contract !== undefined) {
+    if (!isRecord3(value.contract) || !Number.isInteger(value.contract.chainId) || typeof value.contract.name !== "string" || typeof value.contract.symbol !== "string" || !Object.values(ContractStandard).includes(value.contract.standard)) {
+      return false;
+    }
+  }
+  if (value.royalty !== undefined) {
+    if (!isRecord3(value.royalty) || typeof value.royalty.address !== "string" || typeof value.royalty.amount !== "number") {
+      return false;
+    }
+  }
+  return true;
+};
+var list2 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      chain: { type: "string", multiple: true },
+      limit: { type: "string" },
+      page: { type: "string" },
+      "sort-by": { type: "string" },
+      "sort-direction": { type: "string" },
+      status: { type: "string" },
+      testnet: { type: "boolean" },
+      type: { type: "string", multiple: true }
+    }
+  });
+  assertNoExtraPositionals(parsed.positionals, 0);
+  const statuses = ["Draft", "InProgress", "Live", "Migrated", "Disabled"];
+  const status2 = parsed.values.status;
+  if (status2 && !statuses.includes(status2)) {
+    throw new CliError(`Invalid status: ${status2}`, 2);
+  }
+  const sortByValues = ["CREATED_DATE", "NAME"];
+  const sortBy = parsed.values["sort-by"];
+  if (sortBy && !sortByValues.includes(sortBy)) {
+    throw new CliError(`Invalid sort order: ${sortBy}`, 2);
+  }
+  const directions = ["ASC", "DESC"];
+  const sortDirection = parsed.values["sort-direction"];
+  if (sortDirection && !directions.includes(sortDirection)) {
+    throw new CliError(`Invalid sort direction: ${sortDirection}`, 2);
+  }
+  const types = parsed.values.type;
+  if (types?.some((type) => !Object.values(CollectionType).includes(type))) {
+    throw new CliError(`Invalid collection type: ${types.join(", ")}`, 2);
+  }
+  const blockchains = parsed.values.chain?.map((chainId) => {
+    const value = positiveInteger(chainId, "--chain");
+    if (value === undefined)
+      throw new CliError("--chain requires a value", 2);
+    return value;
+  });
+  const context = await createClientContext(runtime, global);
+  const result = unwrap(await context.client.collection.list({
+    blockchains,
+    limit: positiveInteger(parsed.values.limit, "--limit"),
+    page: positiveInteger(parsed.values.page, "--page"),
+    sortBy,
+    sortDirection,
+    status: status2,
+    testnet: parsed.values.testnet,
+    types
+  }));
+  if (global.json)
+    printJson(runtime, result);
+  else
+    printCollectionList(runtime, result);
+};
+var get = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createClientContext(runtime, global);
+  const result = unwrap(await context.client.collection.get({ highlightId }));
+  if (global.json)
+    printJson(runtime, result);
+  else
+    printCollection(runtime, result);
+};
+var create = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      input: { type: "string", short: "i" }
+    }
+  });
+  assertNoExtraPositionals(parsed.positionals, 0);
+  const inputPath = requiredInputPath(parsed.values.input);
+  const input = await readTypedJsonInput(inputPath, runtime, isCollectionCreateInput, "a collection.create object containing name, description, logoMediaId, image, type, and valid contract details");
+  const context = await createClientContext(runtime, global);
+  const collection = unwrap(await context.client.collection.create(input));
+  if (global.json) {
+    printJson(runtime, collection);
+  } else {
+    runtime.stdout(`Created ${collection.name} (${collection.highlightId}) in Draft.`);
+    runtime.stdout(`Type: ${collection.type}`);
+    runtime.stdout(`Chain: ${collection.contract.chainId}`);
+  }
+};
+var waitForDeployment = async (context, highlightId, timeoutSeconds, pollIntervalSeconds, runtime) => {
+  const deadline = runtime.now() + timeoutSeconds * 1000;
+  while (true) {
+    const status2 = unwrap(await context.client.collection.deployStatus({ highlightId }));
+    if (status2.status === "Completed" || status2.status === "Failed" || status2.currentStep === "AwaitTransaction") {
+      return status2;
+    }
+    if (runtime.now() >= deadline) {
+      throw new CliError(`Timed out waiting for deployment ${status2.deploymentId}`);
+    }
+    await runtime.sleep(pollIntervalSeconds * 1000);
+  }
+};
+var deploy = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      "poll-interval": { type: "string" },
+      timeout: { type: "string" },
+      wait: { type: "boolean" }
+    }
+  });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createClientContext(runtime, global);
+  let status2 = unwrap(await context.client.collection.deploy({ highlightId }));
+  if (parsed.values.wait) {
+    status2 = await waitForDeployment(context, highlightId, positiveNumber(parsed.values.timeout, "--timeout") ?? 300, positiveNumber(parsed.values["poll-interval"], "--poll-interval") ?? 2, runtime);
+  }
+  if (global.json)
+    printJson(runtime, status2);
+  else
+    printDeployStatus(runtime, status2);
+  if (status2.status === "Failed") {
+    throw new CliError(status2.error ?? "Deployment failed");
+  }
+};
+var deployStatus = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createClientContext(runtime, global);
+  const status2 = unwrap(await context.client.collection.deployStatus({ highlightId }));
+  if (global.json)
+    printJson(runtime, status2);
+  else
+    printDeployStatus(runtime, status2);
+};
+var deployCancel = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createClientContext(runtime, global);
+  const status2 = unwrap(await context.client.collection.deployCancel({ highlightId }));
+  if (global.json)
+    printJson(runtime, status2);
+  else
+    runtime.stdout(`Cancelled deployment for ${status2.highlightId}.`);
+};
+
+// src/commands/contracts.ts
+var list3 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      cursor: { type: "string" },
+      limit: { type: "string" }
+    }
+  });
+  assertNoExtraPositionals(parsed.positionals, 0);
+  const context = await createClientContext(runtime, global);
+  const result = unwrap(await context.client.contract.list({
+    cursor: parsed.values.cursor,
+    limit: positiveInteger(parsed.values.limit, "--limit")
+  }));
+  if (global.json) {
+    printJson(runtime, result);
+    return;
+  }
+  printTable(runtime, ["ID", "NAME", "SYMBOL", "STANDARD", "TYPE", "CHAIN", "STATUS", "ADDRESS"], result.items.map((contract) => [
+    contract.id,
+    contract.name,
+    contract.symbol,
+    contract.standard,
+    contract.type,
+    contract.chainId,
+    contract.status,
+    contract.address
+  ]));
+  if (result.pageInfo.hasNextPage && result.pageInfo.endCursor) {
+    runtime.stdout(`Next cursor: ${result.pageInfo.endCursor}`);
+  }
+};
+var get2 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const contractId = requiredPositional(parsed.positionals, 0, "contract-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createClientContext(runtime, global);
+  const contract = unwrap(await context.client.contract.get({ contractId }));
+  if (global.json) {
+    printJson(runtime, contract);
+    return;
+  }
+  runtime.stdout(`${contract.name} (${contract.id})`);
+  runtime.stdout(`Symbol: ${contract.symbol}`);
+  runtime.stdout(`Type: ${contract.type} / ${contract.standard}`);
+  runtime.stdout(`Chain: ${contract.chainId}`);
+  runtime.stdout(`Status: ${contract.status}`);
+  runtime.stdout(`Address: ${contract.address ?? "not deployed"}`);
+};
+
+// src/commands/gates.ts
+var isOptionalMatchMode = (value) => value === undefined || Object.values(GateMatchMode).includes(value);
+var isGateCondition = (value) => {
+  if (!isRecord3(value) || !isRecord3(value.config))
+    return false;
+  const config = value.config;
+  switch (value.type) {
+    case "ALLOWLIST":
+      return Array.isArray(config.addresses) && config.addresses.every((address) => typeof address === "string");
+    case "TOKEN_OWNERSHIP":
+      return typeof config.contractAddress === "string" && Number.isInteger(config.chainId) && (config.minAmount === undefined || Number.isInteger(config.minAmount));
+    case "SPECIFIC_TOKEN":
+      return typeof config.contractAddress === "string" && Number.isInteger(config.chainId) && typeof config.tokenId === "string";
+    case "TOKEN_ATTRIBUTE":
+      return typeof config.contractAddress === "string" && Number.isInteger(config.chainId) && typeof config.traitType === "string" && typeof config.traitValue === "string";
+    case "CURRENCY_BALANCE":
+      return Number.isInteger(config.chainId) && isOptionalString(config.contractAddress) && typeof config.minBalance === "string";
+    case "FARCASTER_FOLLOW":
+      return Number.isInteger(config.fid) && isOptionalString(config.username) && isOptionalString(config.displayName) && isOptionalString(config.pfpUrl);
+    default:
+      return false;
+  }
+};
+var isGateCreateInput = (value) => isRecord3(value) && typeof value.name === "string" && isOptionalMatchMode(value.matchMode) && Array.isArray(value.conditions) && value.conditions.every(isGateCondition);
+var isGateUpdateInput = (value) => isRecord3(value) && ["name", "matchMode", "conditions"].some((field) => (field in value)) && isOptionalString(value.name) && isOptionalMatchMode(value.matchMode) && (value.conditions === undefined || Array.isArray(value.conditions) && value.conditions.every(isGateCondition));
+var printGate = (runtime, gate) => {
+  runtime.stdout(`${gate.name} (${gate.id})`);
+  runtime.stdout(`Match: ${gate.matchMode}`);
+  runtime.stdout(`Conditions: ${gate.conditions.map((condition) => condition.type).join(", ")}`);
+};
+var list4 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  assertNoExtraPositionals(parsed.positionals, 0);
+  const context = await createClientContext(runtime, global);
+  const gates = unwrap(await context.client.gate.list());
+  if (global.json) {
+    printJson(runtime, gates);
+    return;
+  }
+  printTable(runtime, ["ID", "NAME", "MATCH", "CONDITIONS"], gates.map((gate) => [gate.id, gate.name, gate.matchMode, gate.conditions.length]));
+};
+var get3 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const gateId = requiredPositional(parsed.positionals, 0, "gate-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createClientContext(runtime, global);
+  const gate = unwrap(await context.client.gate.get({ gateId }));
+  if (global.json)
+    printJson(runtime, gate);
+  else
+    printGate(runtime, gate);
+};
+var create2 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      input: { type: "string", short: "i" }
+    }
+  });
+  assertNoExtraPositionals(parsed.positionals, 0);
+  const input = await readTypedJsonInput(requiredInputPath(parsed.values.input), runtime, isGateCreateInput, "a gate.create body with a name and valid conditions");
+  const context = await createClientContext(runtime, global);
+  const gate = unwrap(await context.client.gate.create(input));
+  if (global.json)
+    printJson(runtime, gate);
+  else {
+    runtime.stdout(`Created gate ${gate.name} (${gate.id}).`);
+    runtime.stdout(`${gate.conditions.length} condition(s), matching ${gate.matchMode}.`);
+  }
+};
+var update = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      input: { type: "string", short: "i" }
+    }
+  });
+  const gateId = requiredPositional(parsed.positionals, 0, "gate-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const input = await readTypedJsonInput(requiredInputPath(parsed.values.input), runtime, isGateUpdateInput, "a non-empty gate.update body");
+  const context = await createClientContext(runtime, global);
+  const gate = unwrap(await context.client.gate.update({ gateId, ...input }));
+  if (global.json)
+    printJson(runtime, gate);
+  else
+    runtime.stdout(`Updated gate ${gate.name} (${gate.id}).`);
+};
+var remove = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const gateId = requiredPositional(parsed.positionals, 0, "gate-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createClientContext(runtime, global);
+  const result = unwrap(await context.client.gate.remove({ gateId }));
+  if (global.json)
+    printJson(runtime, { gateId, ...result });
+  else
+    runtime.stdout(`Deleted gate ${gateId}.`);
+};
+
+// src/commands/media.ts
+import { readFile as readFile3, stat } from "node:fs/promises";
+import path3 from "node:path";
+var MIME_TYPES = {
+  ".css": "text/css",
+  ".gif": "image/gif",
+  ".html": "text/html",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript",
+  ".json": "application/json",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".zip": "application/zip"
+};
+var mimeTypeFor = (filePath) => MIME_TYPES[path3.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+var parseResponseError = async (response) => {
+  const text = await response.text();
+  if (!text)
+    return response.statusText;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+var waitUntilReady = async (mediaId, initial, timeoutSeconds, pollIntervalSeconds, runtime, getMedia) => {
+  const deadline = runtime.now() + timeoutSeconds * 1000;
+  let media2 = initial;
+  while (media2.status !== "Ready" && media2.status !== "Failed") {
+    if (runtime.now() >= deadline) {
+      throw new CliError(`Timed out waiting for media ${mediaId} to become ready`);
+    }
+    await runtime.sleep(pollIntervalSeconds * 1000);
+    media2 = await getMedia();
+  }
+  if (media2.status === "Failed") {
+    throw new CliError(`Media processing failed for ${mediaId}`);
+  }
+  return media2;
+};
+var upload = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      kind: { type: "string" },
+      "mime-type": { type: "string" },
+      "no-wait": { type: "boolean" },
+      "poll-interval": { type: "string" },
+      scope: { type: "string" },
+      timeout: { type: "string" }
+    }
+  });
+  const inputPath = requiredPositional(parsed.positionals, 0, "file");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const absolutePath = path3.resolve(runtime.cwd, inputPath);
+  const fileStat = await stat(absolutePath);
+  if (!fileStat.isFile()) {
+    throw new CliError(`Media input must be a file: ${inputPath}`, 2);
+  }
+  const kindValue = parsed.values.kind?.toLowerCase() ?? "file";
+  const kind = kindValue === "file" ? "File" /* File */ : kindValue === "directory" ? "Directory" /* Directory */ : undefined;
+  if (!kind) {
+    throw new CliError('--kind must be either "file" or "directory"', 2);
+  }
+  if (kind === "Directory" /* Directory */ && path3.extname(absolutePath).toLowerCase() !== ".zip") {
+    throw new CliError("Directory media must be uploaded as a .zip file", 2);
+  }
+  const scopeValue = parsed.values.scope?.toLowerCase() ?? "collection";
+  const scope = scopeValue === "collection" ? "Collection" /* Collection */ : scopeValue === "user" ? "User" /* User */ : undefined;
+  if (!scope) {
+    throw new CliError('--scope must be either "collection" or "user"', 2);
+  }
+  const context = await createClientContext(runtime, global);
+  const session = unwrap(await context.client.media.createUploadSession({
+    fileName: path3.basename(absolutePath),
+    fileSize: fileStat.size,
+    kind,
+    mimeType: parsed.values["mime-type"] ?? mimeTypeFor(absolutePath),
+    scope
+  }));
+  const headers = new Headers(session.upload.headers);
+  if (!headers.has("authorization")) {
+    headers.set("authorization", `Bearer ${context.apiKey}`);
+  }
+  const response = await runtime.fetch(session.upload.url, {
+    body: await readFile3(absolutePath),
+    headers,
+    method: session.upload.method
+  });
+  if (!response.ok) {
+    throw new ApiError(await parseResponseError(response), response.status);
+  }
+  let media2 = unwrap(await context.client.media.get({ mediaId: session.media.id }));
+  if (!parsed.values["no-wait"]) {
+    media2 = await waitUntilReady(media2.id, media2, positiveNumber(parsed.values.timeout, "--timeout") ?? 300, positiveNumber(parsed.values["poll-interval"], "--poll-interval") ?? 2, runtime, async () => unwrap(await context.client.media.get({ mediaId: media2.id })));
+  }
+  const result = {
+    media: media2,
+    url: resolveMediaUrl(media2)
+  };
+  if (global.json)
+    printJson(runtime, result);
+  else
+    printMedia(runtime, media2, result.url);
+};
+var get4 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const mediaId = requiredPositional(parsed.positionals, 0, "media-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createClientContext(runtime, global);
+  const media2 = unwrap(await context.client.media.get({ mediaId }));
+  const result = { media: media2, url: resolveMediaUrl(media2) };
+  if (global.json)
+    printJson(runtime, result);
+  else
+    printMedia(runtime, media2, result.url);
+};
+var publish = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const mediaId = requiredPositional(parsed.positionals, 0, "media-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createClientContext(runtime, global);
+  const media2 = unwrap(await context.client.media.publish({ mediaId }));
+  const result = { media: media2, url: resolveMediaUrl(media2) };
+  if (global.json)
+    printJson(runtime, result);
+  else
+    printMedia(runtime, media2, result.url);
+};
+
+// src/commands/sales.ts
+var isOptionalNumber = (value) => value === undefined || typeof value === "number" && Number.isFinite(value);
+var isOptionalBoolean = (value) => value === undefined || typeof value === "boolean";
+var isSaleCreateInput = (value) => {
+  if (!isRecord3(value))
+    return false;
+  return Object.values(SaleType).includes(value.type) && typeof value.startAt === "string" && typeof value.price === "string" && typeof value.currency === "string" && typeof value.maxPerTransaction === "number" && Number.isFinite(value.maxPerTransaction) && typeof value.maxPerWallet === "number" && Number.isFinite(value.maxPerWallet) && typeof value.maxTotal === "number" && Number.isFinite(value.maxTotal) && typeof value.paymentRecipient === "string" && isOptionalNullableString(value.name) && isOptionalNullableString(value.endAt) && (value.accessMode === undefined || Object.values(SaleAccessMode).includes(value.accessMode)) && isOptionalNullableString(value.gateId) && isOptionalBoolean(value.gasSponsored) && isOptionalNullableString(value.mechanicId) && isOptionalNullableString(value.collectorMessage) && isOptionalNullableString(value.customMintFee);
+};
+var SALE_UPDATE_FIELDS = [
+  "name",
+  "startAt",
+  "endAt",
+  "price",
+  "currency",
+  "maxPerTransaction",
+  "maxPerWallet",
+  "maxTotal",
+  "paymentRecipient",
+  "paused",
+  "collectorMessage",
+  "customMintFee"
+];
+var isSaleUpdateInput = (value) => {
+  if (!isRecord3(value) || !SALE_UPDATE_FIELDS.some((field) => (field in value)))
+    return false;
+  return isOptionalNullableString(value.name) && isOptionalString(value.startAt) && isOptionalNullableString(value.endAt) && isOptionalString(value.price) && isOptionalString(value.currency) && isOptionalNumber(value.maxPerTransaction) && isOptionalNumber(value.maxPerWallet) && isOptionalNumber(value.maxTotal) && isOptionalString(value.paymentRecipient) && isOptionalBoolean(value.paused) && isOptionalNullableString(value.collectorMessage) && isOptionalNullableString(value.customMintFee);
+};
+var list5 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createClientContext(runtime, global);
+  const sales = unwrap(await context.client.collection.getSales({ highlightId }));
+  if (global.json) {
+    printJson(runtime, sales);
+    return;
+  }
+  printTable(runtime, ["ID", "NAME", "TYPE", "ACCESS", "STATUS", "LIFECYCLE", "PRICE", "CURRENCY"], sales.map((sale) => [
+    sale.id,
+    sale.name,
+    sale.type,
+    sale.accessMode,
+    sale.status,
+    sale.lifecycle,
+    sale.price,
+    sale.currency.symbol
+  ]));
+};
+var create3 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      input: { type: "string", short: "i" }
+    }
+  });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const input = await readTypedJsonInput(requiredInputPath(parsed.values.input), runtime, isSaleCreateInput, "a collection.addSale body with type, schedule, price, limits, currency, and paymentRecipient");
+  const context = await createClientContext(runtime, global);
+  const result = unwrap(await context.client.collection.addSale({
+    highlightId,
+    ...input
+  }));
+  if (global.json) {
+    printJson(runtime, result);
+    return;
+  }
+  runtime.stdout(`Created sale ${result.saleId}: ${result.status}.`);
+  if (result.contractExecution) {
+    runtime.stdout("Wallet signature required. Transaction payload:");
+    runtime.stdout(JSON.stringify(result.contractExecution, null, 2));
+  }
+};
+var update2 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      input: { type: "string", short: "i" }
+    }
+  });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  const saleId = requiredPositional(parsed.positionals, 1, "sale-id");
+  assertNoExtraPositionals(parsed.positionals, 2);
+  const input = await readTypedJsonInput(requiredInputPath(parsed.values.input), runtime, isSaleUpdateInput, "a non-empty collection.updateSale body");
+  const context = await createClientContext(runtime, global);
+  const result = unwrap(await context.client.collection.updateSale({
+    highlightId,
+    saleId,
+    ...input
+  }));
+  if (global.json) {
+    printJson(runtime, result);
+    return;
+  }
+  runtime.stdout(`Updated sale ${result.saleId} at ${result.updatedAt}.`);
+  if (result.contractExecution) {
+    runtime.stdout("Wallet signature required. Transaction payload:");
+    runtime.stdout(JSON.stringify(result.contractExecution, null, 2));
+  }
+};
+var remove2 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  const saleId = requiredPositional(parsed.positionals, 1, "sale-id");
+  assertNoExtraPositionals(parsed.positionals, 2);
+  const context = await createClientContext(runtime, global);
+  unwrap(await context.client.collection.deleteSale({ highlightId, saleId }));
+  if (global.json)
+    printJson(runtime, { deleted: true, highlightId, saleId });
+  else
+    runtime.stdout(`Deleted sale ${saleId}.`);
+};
+
+// src/commands/tokens.ts
+var list6 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, {
+    options: {
+      attributes: { type: "string" },
+      limit: { type: "string" },
+      order: { type: "string" },
+      owner: { type: "string" },
+      page: { type: "string" },
+      search: { type: "string" },
+      sort: { type: "string" }
+    }
+  });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const sorts = ["tokenId", "name", "mintedAt", "createdAt"];
+  const sort = parsed.values.sort;
+  if (sort && !sorts.includes(sort)) {
+    throw new CliError(`Invalid token sort: ${sort}`, 2);
+  }
+  const orders = ["asc", "desc"];
+  const order = parsed.values.order;
+  if (order && !orders.includes(order)) {
+    throw new CliError(`Invalid token order: ${order}`, 2);
+  }
+  if (parsed.values.attributes) {
+    try {
+      JSON.parse(parsed.values.attributes);
+    } catch {
+      throw new CliError("--attributes must be a JSON-encoded trait filter array", 2);
+    }
+  }
+  const context = await createPublicClientContext(runtime, global);
+  const result = unwrap(await context.client.token.list({
+    attributes: parsed.values.attributes,
+    highlightId,
+    limit: positiveInteger(parsed.values.limit, "--limit"),
+    order,
+    ownerAddress: parsed.values.owner,
+    page: positiveInteger(parsed.values.page, "--page"),
+    search: parsed.values.search,
+    sort
+  }));
+  if (global.json) {
+    printJson(runtime, result);
+    return;
+  }
+  printTable(runtime, ["TOKEN", "NAME", "STATUS", "MINTED", "IMAGE"], result.items.map((token) => [
+    token.tokenId,
+    token.name,
+    token.status,
+    token.mintedAt,
+    resolveMediaUrl(token.imageMedia)
+  ]));
+  runtime.stdout(`Page ${result.pageInfo.page}/${Math.max(result.pageInfo.totalPages, 1)} · ${result.pageInfo.totalCount} total`);
+};
+var get5 = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  const tokenId = requiredPositional(parsed.positionals, 1, "token-id");
+  assertNoExtraPositionals(parsed.positionals, 2);
+  const context = await createPublicClientContext(runtime, global);
+  const token = unwrap(await context.client.token.get({ highlightId, tokenId }));
+  if (global.json) {
+    printJson(runtime, token);
+    return;
+  }
+  runtime.stdout(`${token.name ?? `Token ${token.tokenId}`} (${token.tokenId})`);
+  runtime.stdout(`Status: ${token.status}`);
+  runtime.stdout(`Image: ${resolveMediaUrl(token.imageMedia) ?? "unavailable"}`);
+  runtime.stdout(`Animation: ${resolveMediaUrl(token.animationMedia) ?? "unavailable"}`);
+  if (token.description)
+    runtime.stdout(`Description: ${token.description}`);
+};
+var owners = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  const tokenId = requiredPositional(parsed.positionals, 1, "token-id");
+  assertNoExtraPositionals(parsed.positionals, 2);
+  const context = await createPublicClientContext(runtime, global);
+  const result = unwrap(await context.client.token.listOwners({ highlightId, tokenId }));
+  if (global.json) {
+    printJson(runtime, result);
+    return;
+  }
+  printTable(runtime, ["OWNER", "BALANCE", "FIRST ACQUIRED"], result.owners.map((owner) => [owner.ownerAddress, owner.balance, owner.firstAcquiredAt]));
+};
+var facets = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createPublicClientContext(runtime, global);
+  const result = unwrap(await context.client.token.attributeFacets({ highlightId }));
+  if (global.json) {
+    printJson(runtime, result);
+    return;
+  }
+  printTable(runtime, ["TRAIT", "VALUE", "COUNT"], result.facets.flatMap((facet) => facet.values.map((value) => [facet.traitType, value.value, value.count])));
+};
+var redrive = async (args, global, runtime) => {
+  const parsed = parseCommandArgs(args, { options: {} });
+  const highlightId = requiredPositional(parsed.positionals, 0, "highlight-id");
+  assertNoExtraPositionals(parsed.positionals, 1);
+  const context = await createClientContext(runtime, global);
+  const result = unwrap(await context.client.token.redriveReveals({ highlightId }));
+  if (global.json) {
+    printJson(runtime, result);
+    return;
+  }
+  runtime.stdout(`Scheduled ${result.scheduled}/${result.candidates} reveal candidates (${result.failed} failed).`);
+};
+
+// src/runtime.ts
+import { homedir } from "node:os";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+var readStdin = async () => {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+};
+var promptSecret = async (prompt) => {
+  let muted = false;
+  const output = new Writable({
+    write(chunk, _encoding, callback) {
+      if (!muted)
+        process.stderr.write(chunk);
+      callback();
+    }
+  });
+  const readline = createInterface({
+    input: process.stdin,
+    output,
+    terminal: true
+  });
+  try {
+    process.stderr.write(prompt);
+    muted = true;
+    return await readline.question("");
+  } finally {
+    readline.close();
+    process.stderr.write(`
+`);
+  }
+};
+var defaults = {
+  cwd: process.cwd(),
+  env: process.env,
+  fetch: globalThis.fetch,
+  homeDir: homedir(),
+  now: () => Date.now(),
+  promptSecret,
+  readStdin,
+  sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+  stderr: (message) => process.stderr.write(`${message}
+`),
+  stdout: (message) => process.stdout.write(`${message}
+`)
+};
+var createRuntime = (overrides = {}) => ({
+  ...defaults,
+  ...overrides
+});
+
+// src/cli.ts
+var MAIN_HELP = `Highlight CLI
+
+Usage:
+  hl [global options] <command>
+
+Commands:
+  auth login                         Save and verify an API key
+  auth status                        Verify the active credentials
+  auth logout                        Remove a saved API key
+  collections list                   List your collections
+  collections get <highlight-id>     Get a collection
+  collections create --input <file>  Create a draft from JSON
+  collections deploy <id>            Start a deployment
+  collections deploy-status <id>     Get deployment status
+  collections deploy-cancel <id>     Cancel a deployment
+  sales list <collection-id>          List collection sales
+  sales create <id> --input <file>    Create a sale
+  sales update <id> <sale-id>         Update a sale
+  sales delete <id> <sale-id>         Delete a draft sale
+  gates list|get|create|update|delete  Manage reusable access gates
+  contracts list|get                  Inspect your contracts
+  tokens list|get|owners|facets        Inspect minted tokens
+  tokens redrive <collection-id>       Re-drive stuck token reveals
+  chains list                          List supported chains
+  chains system-contract <id> <type>  Resolve a system contract
+  media upload <file>                Upload and process media
+  media get <media-id>               Get media details
+  media publish <media-id>           Publish media to the archive
+
+Aliases:
+  hl create ...                      hl collections create ...
+  hl deploy ...                      hl collections deploy ...
+
+Global options:
+  --api-url <url>                    Override the Highlight API URL
+  --profile <name>                   Use a named credential profile
+  --json                             Print machine-readable JSON
+  -h, --help                         Show help
+  -v, --version                      Show version
+
+Environment:
+  HIGHLIGHT_API_KEY                  Override the saved API key
+  HIGHLIGHT_API_URL                  Override the API URL
+  HIGHLIGHT_CONFIG_DIR               Override the config directory`;
+var AUTH_HELP = `Usage:
+  hl auth login [--api-key <key> | --api-key-stdin]
+  hl auth status
+  hl auth logout
+
+API keys are saved in a mode-0600 config file. HIGHLIGHT_API_KEY always takes
+precedence over saved credentials.`;
+var COLLECTIONS_HELP = `Usage:
+  hl collections list [options]
+  hl collections get <highlight-id>
+  hl collections create --input <file|->
+  hl collections deploy <highlight-id> [--wait]
+  hl collections deploy-status <highlight-id>
+  hl collections deploy-cancel <highlight-id>
+
+List options:
+  --page <number>                    Page number
+  --limit <number>                   Page size
+  --status <status>                  Draft, InProgress, Live, Migrated, Disabled
+  --chain <chain-id>                 Filter by chain; repeatable
+  --type <type>                      Filter by collection type; repeatable
+  --testnet                          Return testnet collections
+  --sort-by <CREATED_DATE|NAME>
+  --sort-direction <ASC|DESC>
+
+Deploy options:
+  --wait                             Poll until completion or wallet action
+  --timeout <seconds>                Wait timeout (default: 300)
+  --poll-interval <seconds>          Poll interval (default: 2)`;
+var MEDIA_HELP = `Usage:
+  hl media upload <file> [options]
+  hl media get <media-id>
+  hl media publish <media-id>
+
+Upload options:
+  --kind <file|directory>            Directory inputs must be .zip files
+  --scope <collection|user>          Media scope (default: collection)
+  --mime-type <type>                 Override inferred MIME type
+  --no-wait                          Return before processing is ready
+  --timeout <seconds>                Wait timeout (default: 300)
+  --poll-interval <seconds>          Poll interval (default: 2)`;
+var SALES_HELP = `Usage:
+  hl sales list <highlight-id>
+  hl sales create <highlight-id> --input <file|->
+  hl sales update <highlight-id> <sale-id> --input <file|->
+  hl sales delete <highlight-id> <sale-id>
+
+Create and update inputs use the SDK collection.addSale and
+collection.updateSale body shapes. Sale compatibility is validated by the API.`;
+var GATES_HELP = `Usage:
+  hl gates list
+  hl gates get <gate-id>
+  hl gates create --input <file|->
+  hl gates update <gate-id> --input <file|->
+  hl gates delete <gate-id>
+
+Create and update inputs use the SDK gate.create and gate.update body shapes.`;
+var CONTRACTS_HELP = `Usage:
+  hl contracts list [--limit <number>] [--cursor <cursor>]
+  hl contracts get <contract-id>`;
+var TOKENS_HELP = `Usage:
+  hl tokens list <highlight-id> [options]
+  hl tokens get <highlight-id> <token-id>
+  hl tokens owners <highlight-id> <token-id>
+  hl tokens facets <highlight-id>
+  hl tokens redrive <highlight-id>
+
+List options:
+  --page <number>
+  --limit <number>
+  --sort <tokenId|name|mintedAt|createdAt>
+  --order <asc|desc>
+  --owner <address>
+  --search <text>
+  --attributes <json>                Trait filters as a JSON-encoded array`;
+var CHAINS_HELP = `Usage:
+  hl chains list [--mainnet | --testnet]
+  hl chains system-contract <chain-id> <contract-type>`;
+var helpFor = (args) => {
+  switch (args[0]) {
+    case "auth":
+      return AUTH_HELP;
+    case "collection":
+    case "collections":
+    case "create":
+    case "deploy":
+      return COLLECTIONS_HELP;
+    case "media":
+      return MEDIA_HELP;
+    case "sales":
+      return SALES_HELP;
+    case "gates":
+      return GATES_HELP;
+    case "contracts":
+      return CONTRACTS_HELP;
+    case "tokens":
+      return TOKENS_HELP;
+    case "chains":
+      return CHAINS_HELP;
+    default:
+      return MAIN_HELP;
+  }
+};
+var runCommand = async (args, global, runtime) => {
+  const [command, subcommand, ...rest] = args;
+  if (command === "auth") {
+    if (subcommand === "login")
+      return login(rest, global, runtime);
+    if (subcommand === "status")
+      return status(rest, global, runtime);
+    if (subcommand === "logout")
+      return logout(rest, global, runtime);
+    throw new CliError(`Unknown auth command: ${subcommand ?? "(missing)"}`, 2);
+  }
+  if (command === "collections" || command === "collection") {
+    if (subcommand === "list")
+      return list2(rest, global, runtime);
+    if (subcommand === "get")
+      return get(rest, global, runtime);
+    if (subcommand === "create")
+      return create(rest, global, runtime);
+    if (subcommand === "deploy")
+      return deploy(rest, global, runtime);
+    if (subcommand === "deploy-status")
+      return deployStatus(rest, global, runtime);
+    if (subcommand === "deploy-cancel")
+      return deployCancel(rest, global, runtime);
+    throw new CliError(`Unknown collections command: ${subcommand ?? "(missing)"}`, 2);
+  }
+  if (command === "media") {
+    if (subcommand === "upload")
+      return upload(rest, global, runtime);
+    if (subcommand === "get")
+      return get4(rest, global, runtime);
+    if (subcommand === "publish")
+      return publish(rest, global, runtime);
+    throw new CliError(`Unknown media command: ${subcommand ?? "(missing)"}`, 2);
+  }
+  if (command === "sales") {
+    if (subcommand === "list")
+      return list5(rest, global, runtime);
+    if (subcommand === "create")
+      return create3(rest, global, runtime);
+    if (subcommand === "update")
+      return update2(rest, global, runtime);
+    if (subcommand === "delete")
+      return remove2(rest, global, runtime);
+    throw new CliError(`Unknown sales command: ${subcommand ?? "(missing)"}`, 2);
+  }
+  if (command === "gates") {
+    if (subcommand === "list")
+      return list4(rest, global, runtime);
+    if (subcommand === "get")
+      return get3(rest, global, runtime);
+    if (subcommand === "create")
+      return create2(rest, global, runtime);
+    if (subcommand === "update")
+      return update(rest, global, runtime);
+    if (subcommand === "delete")
+      return remove(rest, global, runtime);
+    throw new CliError(`Unknown gates command: ${subcommand ?? "(missing)"}`, 2);
+  }
+  if (command === "contracts") {
+    if (subcommand === "list")
+      return list3(rest, global, runtime);
+    if (subcommand === "get")
+      return get2(rest, global, runtime);
+    throw new CliError(`Unknown contracts command: ${subcommand ?? "(missing)"}`, 2);
+  }
+  if (command === "tokens") {
+    if (subcommand === "list")
+      return list6(rest, global, runtime);
+    if (subcommand === "get")
+      return get5(rest, global, runtime);
+    if (subcommand === "owners")
+      return owners(rest, global, runtime);
+    if (subcommand === "facets")
+      return facets(rest, global, runtime);
+    if (subcommand === "redrive")
+      return redrive(rest, global, runtime);
+    throw new CliError(`Unknown tokens command: ${subcommand ?? "(missing)"}`, 2);
+  }
+  if (command === "chains") {
+    if (subcommand === "list")
+      return list(rest, global, runtime);
+    if (subcommand === "system-contract")
+      return systemContract(rest, global, runtime);
+    throw new CliError(`Unknown chains command: ${subcommand ?? "(missing)"}`, 2);
+  }
+  if (command === "create") {
+    return create(args.slice(1), global, runtime);
+  }
+  if (command === "deploy") {
+    return deploy(args.slice(1), global, runtime);
+  }
+  throw new CliError(`Unknown command: ${command ?? "(missing)"}`, 2);
+};
+var runCli = async (argv, runtimeOverrides = {}) => {
+  const runtime = createRuntime(runtimeOverrides);
+  let extracted;
+  try {
+    extracted = extractGlobalOptions(argv);
+  } catch (error) {
+    runtime.stderr(`Error: ${toErrorMessage(error)}`);
+    return error instanceof CliError ? error.exitCode : 1;
+  }
+  const { args, global } = extracted;
+  if (global.version) {
+    runtime.stdout(package_default.version);
+    return 0;
+  }
+  if (global.help || args.length === 0) {
+    runtime.stdout(helpFor(args));
+    return 0;
+  }
+  try {
+    await runCommand(args, global, runtime);
+    return 0;
+  } catch (error) {
+    if (global.json) {
+      const payload = {
+        error: toErrorMessage(error)
+      };
+      if (error instanceof ApiError) {
+        payload.details = error.details;
+        payload.status = error.status;
+      }
+      runtime.stderr(JSON.stringify(payload, null, 2));
+    } else {
+      runtime.stderr(`Error: ${toErrorMessage(error)}`);
+    }
+    return error instanceof CliError ? error.exitCode : 1;
+  }
+};
+
+// src/index.ts
+process.exitCode = await runCli(process.argv.slice(2));