@microsoft/webiq 0.0.1-alpha.2 → 0.1.1

package/dist/index.mjs

@@ -0,0 +1,792 @@
+// src/auth.ts
+var DEFAULT_SCOPE = "https://api.microsoft.ai/.default";
+var ApiKeyAuth = class {
+  apiKey;
+  constructor(apiKey) {
+    const trimmed = typeof apiKey === "string" ? apiKey.trim() : "";
+    if (!trimmed) {
+      throw new Error("apiKey must be a non-empty string");
+    }
+    this.apiKey = trimmed;
+  }
+  async getHeaders() {
+    return { "x-apikey": this.apiKey };
+  }
+};
+var EntraIDAuth = class {
+  credential;
+  scope;
+  constructor(credential, options) {
+    if (credential === null || credential === void 0) {
+      throw new Error("credential must be a TokenCredential instance");
+    }
+    if (typeof credential.getToken !== "function") {
+      throw new Error("credential must implement getToken(scopes, options?)");
+    }
+    const rawScope = options?.scope;
+    const scope = rawScope === void 0 || rawScope === null ? DEFAULT_SCOPE : typeof rawScope === "string" ? rawScope.trim() : "";
+    if (!scope) {
+      throw new Error("scope must be a non-empty string");
+    }
+    this.credential = credential;
+    this.scope = scope;
+  }
+  async getHeaders() {
+    const tokenResponse = await this.credential.getToken(this.scope);
+    if (!tokenResponse || !tokenResponse.token) {
+      throw new Error("TokenCredential.getToken returned no token");
+    }
+    return { Authorization: `Bearer ${tokenResponse.token}` };
+  }
+};
+function createAuth(options) {
+  if (options.credential) {
+    return new EntraIDAuth(options.credential, { scope: options.scope });
+  }
+  if (options.apiKey !== void 0) {
+    return new ApiKeyAuth(options.apiKey);
+  }
+  throw new Error("Either apiKey or credential must be provided");
+}
+
+// src/resources/web.ts
+var WebResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Search the web for relevant content.
+   *
+   * @param query - Search query string (1-1000 chars)
+   * @param options - Search options
+   * @returns WebResponse with webResults list and traceId
+   */
+  async search(query, options) {
+    const payload = { query };
+    if (options?.maxResults !== void 0) {
+      payload.maxResults = options.maxResults;
+    }
+    if (options?.language !== void 0) {
+      payload.language = options.language;
+    }
+    if (options?.region !== void 0) {
+      payload.region = options.region;
+    }
+    if (options?.contentFormat !== void 0) {
+      payload.contentFormat = options.contentFormat;
+    }
+    if (options?.location) {
+      payload.location = options.location;
+    }
+    if (options?.maxLength !== void 0) {
+      payload.maxLength = options.maxLength;
+    }
+    const result = await this.transport.request({
+      method: "POST",
+      path: "/search/web",
+      json: payload,
+      timeout: options?.timeout,
+      signal: options?.signal
+    });
+    return result;
+  }
+};
+
+// src/resources/news.ts
+var NewsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Search for news articles.
+   *
+   * @param query - Search query string (1-1000 chars)
+   * @param options - Search options
+   * @returns NewsResponse with newsResults list and traceId
+   */
+  async search(query, options) {
+    const payload = { query };
+    if (options?.maxResults !== void 0) {
+      payload.maxResults = options.maxResults;
+    }
+    if (options?.language !== void 0) {
+      payload.language = options.language;
+    }
+    if (options?.region !== void 0) {
+      payload.region = options.region;
+    }
+    if (options?.location !== void 0) {
+      payload.location = options.location;
+    }
+    if (options?.contentFormat !== void 0) {
+      payload.contentFormat = options.contentFormat;
+    }
+    if (options?.maxLength !== void 0) {
+      payload.maxLength = options.maxLength;
+    }
+    const result = await this.transport.request({
+      method: "POST",
+      path: "/search/news",
+      json: payload,
+      timeout: options?.timeout,
+      signal: options?.signal
+    });
+    return result;
+  }
+};
+
+// src/resources/videos.ts
+var VideosResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Search for videos.
+   *
+   * @param query - Search query string (1-1000 chars)
+   * @param options - Search options
+   * @returns VideosResponse with videoResults, playlists, and traceId
+   */
+  async search(query, options) {
+    const payload = { query };
+    if (options?.maxResults !== void 0) {
+      payload.maxResults = options.maxResults;
+    }
+    if (options?.language !== void 0) {
+      payload.language = options.language;
+    }
+    if (options?.region !== void 0) {
+      payload.region = options.region;
+    }
+    if (options?.enablePlaylist !== void 0) {
+      payload.enablePlaylist = options.enablePlaylist;
+    }
+    if (options?.freshness !== void 0) {
+      payload.freshness = options.freshness;
+    }
+    if (options?.embeddable !== void 0) {
+      payload.embeddable = options.embeddable;
+    }
+    if (options?.resolution !== void 0) {
+      payload.resolution = options.resolution;
+    }
+    if (options?.safeSearch !== void 0) {
+      payload.safeSearch = options.safeSearch;
+    }
+    if (options?.duration !== void 0) {
+      payload.duration = options.duration;
+    }
+    const result = await this.transport.request({
+      method: "POST",
+      path: "/search/videos",
+      json: payload,
+      timeout: options?.timeout,
+      signal: options?.signal
+    });
+    return result;
+  }
+};
+
+// src/resources/images.ts
+var ImagesResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Search for images.
+   *
+   * @param query - Search query string (1-1000 chars)
+   * @param options - Search options
+   * @returns ImagesResponse with imageResults and traceId
+   */
+  async search(query, options) {
+    const payload = { query };
+    if (options?.maxResults !== void 0) {
+      payload.maxResults = options.maxResults;
+    }
+    if (options?.language !== void 0) {
+      payload.language = options.language;
+    }
+    if (options?.region !== void 0) {
+      payload.region = options.region;
+    }
+    if (options?.aspectRatio !== void 0) {
+      payload.aspectRatio = options.aspectRatio;
+    }
+    if (options?.color !== void 0) {
+      payload.color = options.color;
+    }
+    if (options?.safeSearch !== void 0) {
+      payload.safeSearch = options.safeSearch;
+    }
+    if (options?.imageSize !== void 0) {
+      payload.imageSize = options.imageSize;
+    }
+    if (options?.watermarkFree !== void 0) {
+      payload.watermarkFree = options.watermarkFree;
+    }
+    if (options?.maxHeight !== void 0) {
+      payload.maxHeight = options.maxHeight;
+    }
+    if (options?.minHeight !== void 0) {
+      payload.minHeight = options.minHeight;
+    }
+    if (options?.maxWidth !== void 0) {
+      payload.maxWidth = options.maxWidth;
+    }
+    if (options?.minWidth !== void 0) {
+      payload.minWidth = options.minWidth;
+    }
+    const result = await this.transport.request({
+      method: "POST",
+      path: "/search/images",
+      json: payload,
+      timeout: options?.timeout,
+      signal: options?.signal
+    });
+    return result;
+  }
+};
+
+// src/resources/browse.ts
+var BrowseResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Fetch and extract content from a web page.
+   *
+   * @param url - The URL of the web page to browse
+   * @param options - Fetch options
+   * @returns BrowseResponse with url, content, traceId, and optional retryAfter
+   */
+  async fetch(url, options) {
+    const payload = { url };
+    if (options?.language !== void 0) {
+      payload.language = options.language;
+    }
+    if (options?.region !== void 0) {
+      payload.region = options.region;
+    }
+    if (options?.contentFormat !== void 0) {
+      payload.contentFormat = options.contentFormat;
+    }
+    if (options?.maxLength !== void 0) {
+      payload.maxLength = options.maxLength;
+    }
+    if (options?.liveCrawl !== void 0) {
+      payload.liveCrawl = options.liveCrawl;
+    }
+    if (options?.includeWebLinks !== void 0) {
+      payload.includeWebLinks = options.includeWebLinks;
+    }
+    if (options?.renderDynamicPages !== void 0) {
+      payload.renderDynamicPages = options.renderDynamicPages;
+    }
+    if (options?.includeImageLinks !== void 0) {
+      payload.includeImageLinks = options.includeImageLinks;
+    }
+    const result = await this.transport.request({
+      method: "POST",
+      path: "/browse",
+      json: payload,
+      timeout: options?.timeout,
+      signal: options?.signal
+    });
+    return result;
+  }
+};
+
+// src/resources/classic.ts
+var ClassicResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Perform a classic search returning grouped results across multiple answer types.
+   *
+   * @param query - Search query string (1-1000 chars)
+   * @param options - Search options
+   * @returns SearchClassicResponse with querySignals, traceId, and additional answer types
+   */
+  async search(query, options) {
+    const payload = { query };
+    if (options?.language !== void 0) {
+      payload.language = options.language;
+    }
+    if (options?.region !== void 0) {
+      payload.region = options.region;
+    }
+    if (options?.maxAnswerTypes !== void 0) {
+      payload.maxAnswerTypes = options.maxAnswerTypes;
+    }
+    if (options?.location) {
+      payload.location = options.location;
+    }
+    if (options?.maxResultsWeb !== void 0) {
+      payload.maxResultsWeb = options.maxResultsWeb;
+    }
+    if (options?.maxLength !== void 0) {
+      payload.maxLength = options.maxLength;
+    }
+    if (options?.contentFormat !== void 0) {
+      payload.contentFormat = options.contentFormat;
+    }
+    if (options?.freshness !== void 0) {
+      payload.freshness = options.freshness;
+    }
+    if (options?.responseFilter !== void 0) {
+      payload.responseFilter = options.responseFilter;
+    }
+    if (options?.safeSearch !== void 0) {
+      payload.safeSearch = options.safeSearch;
+    }
+    const result = await this.transport.request({
+      method: "POST",
+      path: "/search/classic",
+      json: payload,
+      timeout: options?.timeout,
+      signal: options?.signal
+    });
+    return result;
+  }
+};
+
+// src/errors.ts
+var WebIQError = class _WebIQError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "WebIQError";
+    Object.setPrototypeOf(this, _WebIQError.prototype);
+  }
+};
+var APIConnectionError = class _APIConnectionError extends WebIQError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "APIConnectionError";
+    Object.setPrototypeOf(this, _APIConnectionError.prototype);
+  }
+};
+var APIStatusError = class _APIStatusError extends WebIQError {
+  statusCode;
+  body;
+  requestId;
+  traceId;
+  constructor(statusCode, message, options) {
+    super(message);
+    this.name = "APIStatusError";
+    this.statusCode = statusCode;
+    this.body = options?.body;
+    this.requestId = options?.requestId;
+    this.traceId = options?.traceId;
+    Object.setPrototypeOf(this, _APIStatusError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends APIStatusError {
+  constructor(statusCode, message, options) {
+    super(statusCode, message, options);
+    this.name = "RateLimitError";
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+  /** The retry-after value from the API response body, if available. */
+  get retryAfter() {
+    if (this.body && typeof this.body === "object" && "retryAfter" in this.body) {
+      return String(this.body.retryAfter);
+    }
+    return void 0;
+  }
+};
+var AuthenticationError = class _AuthenticationError extends APIStatusError {
+  constructor(statusCode, message, options) {
+    super(statusCode, message, options);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var PermissionDeniedError = class _PermissionDeniedError extends APIStatusError {
+  constructor(statusCode, message, options) {
+    super(statusCode, message, options);
+    this.name = "PermissionDeniedError";
+    Object.setPrototypeOf(this, _PermissionDeniedError.prototype);
+  }
+};
+
+// src/retry.ts
+function parseRetryAfter(retryAfter) {
+  if (typeof retryAfter !== "string") {
+    return void 0;
+  }
+  const trimmed = retryAfter.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  if (trimmed.endsWith("s") && !trimmed.endsWith("ms")) {
+    const value = parseFloat(trimmed.slice(0, -1));
+    if (!isNaN(value) && isFinite(value) && value >= 0) {
+      return value;
+    }
+  }
+  if (/^\d{4}-\d{2}-\d{2}T/.test(trimmed)) {
+    const ms = Date.parse(trimmed);
+    if (!isNaN(ms)) {
+      return Math.max(0, (ms - Date.now()) / 1e3);
+    }
+  }
+  return void 0;
+}
+var RetryPolicy = class {
+  maxRetries;
+  baseDelaySeconds;
+  maxDelaySeconds;
+  retryOnStatus;
+  constructor(options) {
+    this.maxRetries = options?.maxRetries ?? 2;
+    this.baseDelaySeconds = options?.baseDelaySeconds ?? 0.25;
+    this.maxDelaySeconds = options?.maxDelaySeconds ?? 4;
+    this.retryOnStatus = new Set(options?.retryOnStatus ?? [408, 500, 502, 503, 504]);
+  }
+  /**
+   * Compute the delay before the next retry attempt.
+   *
+   * @param attempt - Current attempt number (1-based)
+   * @param retryAfter - Server-specified retry-after value (if any)
+   * @returns Delay in seconds before next attempt
+   */
+  computeDelay(attempt, retryAfter) {
+    if (retryAfter !== void 0) {
+      return Math.min(retryAfter, this.maxDelaySeconds);
+    }
+    const delay = Math.random() * this.baseDelaySeconds * Math.pow(2, attempt - 1);
+    return Math.min(delay, this.maxDelaySeconds);
+  }
+  /**
+   * Check if a status code should trigger a retry.
+   */
+  shouldRetry(statusCode) {
+    return this.retryOnStatus.has(statusCode);
+  }
+};
+function sleep(seconds) {
+  return new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+}
+
+// src/telemetry.ts
+function safeCall(hook, event) {
+  if (hook) {
+    try {
+      hook(event);
+    } catch {
+    }
+  }
+}
+function createTelemetryEvent(method, path, transport, attempt, options) {
+  return {
+    method,
+    path,
+    transport,
+    attempt,
+    ...options
+  };
+}
+
+// src/transports/base.ts
+var DEFAULT_TIMEOUT = 1e4;
+
+// src/transports/http.ts
+function extractMetadata(body, headers) {
+  let bodyTraceId;
+  let bodyRetryAfter;
+  let bodyRequestId;
+  if (body && typeof body === "object") {
+    const obj = body;
+    bodyTraceId = typeof obj.traceId === "string" ? obj.traceId : void 0;
+    bodyRetryAfter = typeof obj.retryAfter === "string" ? obj.retryAfter : void 0;
+    bodyRequestId = typeof obj.requestId === "string" ? obj.requestId : void 0;
+  }
+  const headerTraceId = headers?.get("x-traceid") ?? void 0;
+  return {
+    traceId: headerTraceId || bodyTraceId,
+    retryAfter: bodyRetryAfter,
+    requestId: bodyRequestId
+  };
+}
+var HttpTransport = class {
+  baseUrl;
+  auth;
+  telemetry;
+  retry;
+  timeout;
+  fetchFn;
+  activeControllers = /* @__PURE__ */ new Set();
+  closed = false;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.auth = options.auth;
+    this.telemetry = options.telemetryHook;
+    this.retry = options.retry ?? new RetryPolicy();
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    this.fetchFn = options.fetchFn ?? globalThis.fetch.bind(globalThis);
+  }
+  async request(options) {
+    const { method, path, json, signal: callerSignal } = options;
+    const effectiveTimeout = options.timeout ?? this.timeout;
+    let attempt = 0;
+    while (true) {
+      if (this.closed) {
+        throw new APIConnectionError("Transport is closed");
+      }
+      if (callerSignal?.aborted) {
+        throw callerSignal.reason ?? new DOMException("Request aborted", "AbortError");
+      }
+      attempt++;
+      const start = Date.now();
+      try {
+        const authHeaders = await this.auth.getHeaders();
+        const abortController = new AbortController();
+        this.activeControllers.add(abortController);
+        const timeoutId = setTimeout(() => abortController.abort(), effectiveTimeout);
+        const fetchSignal = callerSignal ? AbortSignal.any([callerSignal, abortController.signal]) : abortController.signal;
+        let response;
+        try {
+          response = await this.fetchFn(`${this.baseUrl}${path}`, {
+            method,
+            headers: {
+              "Content-Type": "application/json",
+              ...authHeaders
+            },
+            body: json ? JSON.stringify(json) : void 0,
+            signal: fetchSignal
+          });
+          clearTimeout(timeoutId);
+          this.activeControllers.delete(abortController);
+        } catch (fetchError) {
+          clearTimeout(timeoutId);
+          this.activeControllers.delete(abortController);
+          throw fetchError;
+        }
+        let body = null;
+        const responseText = await response.text();
+        if (responseText) {
+          try {
+            body = JSON.parse(responseText);
+          } catch {
+            body = { rawContent: responseText.slice(0, 500) };
+          }
+        }
+        const { traceId, retryAfter, requestId } = extractMetadata(body, response.headers);
+        const elapsed = Date.now() - start;
+        safeCall(
+          this.telemetry,
+          createTelemetryEvent(method, path, "http", attempt, {
+            statusCode: response.status,
+            requestId,
+            traceId,
+            retryAfter,
+            elapsedMs: elapsed,
+            errorBody: response.status >= 400 ? body : void 0
+          })
+        );
+        if (response.status === 401) {
+          throw new AuthenticationError(response.status, "Unauthorized", {
+            body,
+            requestId,
+            traceId
+          });
+        }
+        if (response.status === 403) {
+          const message = body && typeof body === "object" && "userMessage" in body ? String(body.userMessage) : "Forbidden";
+          throw new PermissionDeniedError(response.status, message, {
+            body,
+            requestId,
+            traceId
+          });
+        }
+        if (response.status === 429 || response.status === 430) {
+          const defaultMessage = response.status === 430 ? "Concurrent request limit exceeded" : "Rate limit exceeded";
+          const message = body && typeof body === "object" && "userMessage" in body ? String(body.userMessage) : defaultMessage;
+          throw new RateLimitError(response.status, message, { body, requestId, traceId });
+        }
+        if (this.retry.shouldRetry(response.status) && attempt <= this.retry.maxRetries) {
+          const delay = this.retry.computeDelay(attempt, parseRetryAfter(retryAfter));
+          await sleep(delay);
+          continue;
+        }
+        if (response.status >= 400) {
+          const message = body && typeof body === "object" && "userMessage" in body ? String(body.userMessage) : `HTTP ${response.status}`;
+          throw new APIStatusError(response.status, message, { body, requestId, traceId });
+        }
+        return body;
+      } catch (error) {
+        if (error instanceof APIStatusError || error instanceof AuthenticationError) {
+          throw error;
+        }
+        const elapsed = Date.now() - start;
+        safeCall(
+          this.telemetry,
+          createTelemetryEvent(method, path, "http", attempt, {
+            elapsedMs: elapsed,
+            error: error instanceof Error ? error : new Error(String(error))
+          })
+        );
+        if (this.closed) {
+          throw new APIConnectionError("Transport is closed");
+        }
+        if (callerSignal?.aborted) {
+          throw callerSignal.reason ?? new DOMException("Request aborted", "AbortError");
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new APIConnectionError(`Request timed out after ${effectiveTimeout}ms`, {
+            cause: error
+          });
+        }
+        if (attempt <= this.retry.maxRetries) {
+          await sleep(this.retry.computeDelay(attempt));
+          continue;
+        }
+        throw new APIConnectionError(
+          error instanceof Error ? error.message : String(error),
+          error instanceof Error ? { cause: error } : void 0
+        );
+      }
+    }
+  }
+  async close() {
+    this.closed = true;
+    Array.from(this.activeControllers).forEach((controller) => controller.abort());
+    this.activeControllers.clear();
+  }
+};
+
+// src/client.ts
+var WebIQClient = class {
+  /** Web search resource */
+  web;
+  /** News search resource */
+  news;
+  /** Videos search resource */
+  videos;
+  /** Images search resource */
+  images;
+  /** Browse resource */
+  browse;
+  /** Classic search resource */
+  classic;
+  _transport;
+  _auth;
+  constructor(options) {
+    if (options.auth) {
+      this._auth = options.auth;
+    } else if (options.credential) {
+      this._auth = createAuth({ credential: options.credential, scope: options.scope });
+    } else if (options.apiKey !== void 0) {
+      this._auth = createAuth({ apiKey: options.apiKey });
+    } else {
+      throw new Error("One of apiKey, credential, or auth must be provided");
+    }
+    const retry = options.retry instanceof RetryPolicy ? options.retry : options.retry ? new RetryPolicy(options.retry) : new RetryPolicy();
+    this._transport = new HttpTransport({
+      baseUrl: options.baseUrl ?? "https://api.microsoft.ai/v3",
+      auth: this._auth,
+      telemetryHook: options.telemetryHook,
+      retry,
+      timeout: options.timeout ?? DEFAULT_TIMEOUT,
+      fetchFn: options.fetchFn
+    });
+    this.web = new WebResource(this._transport);
+    this.news = new NewsResource(this._transport);
+    this.videos = new VideosResource(this._transport);
+    this.images = new ImagesResource(this._transport);
+    this.browse = new BrowseResource(this._transport);
+    this.classic = new ClassicResource(this._transport);
+  }
+  /**
+   * Close the client and release resources.
+   */
+  async close() {
+    await this._transport.close();
+  }
+};
+function createClient(options) {
+  return new WebIQClient(options);
+}
+
+// src/generated-otc/models/BrowseContentFormat.ts
+var BrowseContentFormat = /* @__PURE__ */ ((BrowseContentFormat2) => {
+  BrowseContentFormat2["TEXT"] = "text";
+  BrowseContentFormat2["HTML"] = "html";
+  BrowseContentFormat2["MARKDOWN"] = "markdown";
+  return BrowseContentFormat2;
+})(BrowseContentFormat || {});
+
+// src/generated-otc/models/ContentFormat.ts
+var ContentFormat = /* @__PURE__ */ ((ContentFormat2) => {
+  ContentFormat2["PASSAGE"] = "passage";
+  ContentFormat2["TEXT"] = "text";
+  ContentFormat2["HTML"] = "html";
+  ContentFormat2["MARKDOWN"] = "markdown";
+  return ContentFormat2;
+})(ContentFormat || {});
+
+// src/generated-otc/models/SafeSearch.ts
+var SafeSearch = /* @__PURE__ */ ((SafeSearch2) => {
+  SafeSearch2["OFF"] = "off";
+  SafeSearch2["STRICT"] = "strict";
+  return SafeSearch2;
+})(SafeSearch || {});
+
+// src/generated-otc/models/SafeSearchMode.ts
+var SafeSearchMode = /* @__PURE__ */ ((SafeSearchMode2) => {
+  SafeSearchMode2["OFF"] = "off";
+  SafeSearchMode2["MODERATE"] = "moderate";
+  SafeSearchMode2["STRICT"] = "strict";
+  return SafeSearchMode2;
+})(SafeSearchMode || {});
+
+// src/generated-otc/models/VideoDuration.ts
+var VideoDuration = /* @__PURE__ */ ((VideoDuration2) => {
+  VideoDuration2["SHORT"] = "short";
+  VideoDuration2["MEDIUM"] = "medium";
+  VideoDuration2["LONG"] = "long";
+  return VideoDuration2;
+})(VideoDuration || {});
+
+// src/generated-otc/models/VideoResolution.ts
+var VideoResolution = /* @__PURE__ */ ((VideoResolution2) => {
+  VideoResolution2["_360P"] = "360p";
+  VideoResolution2["_480P"] = "480p";
+  VideoResolution2["_720P"] = "720p";
+  VideoResolution2["_1080P"] = "1080p";
+  return VideoResolution2;
+})(VideoResolution || {});
+
+// src/generated-otc/models/ImageAspectRatio.ts
+var ImageAspectRatio = /* @__PURE__ */ ((ImageAspectRatio2) => {
+  ImageAspectRatio2["SQUARE"] = "square";
+  ImageAspectRatio2["WIDE"] = "wide";
+  ImageAspectRatio2["TALL"] = "tall";
+  return ImageAspectRatio2;
+})(ImageAspectRatio || {});
+
+// src/generated-otc/models/ImageColor.ts
+var ImageColor = /* @__PURE__ */ ((ImageColor2) => {
+  ImageColor2["COLOR_ONLY"] = "colorOnly";
+  ImageColor2["MONOCHROME"] = "monochrome";
+  return ImageColor2;
+})(ImageColor || {});
+
+// src/generated-otc/models/ImageSize.ts
+var ImageSize = /* @__PURE__ */ ((ImageSize2) => {
+  ImageSize2["SMALL"] = "small";
+  ImageSize2["MEDIUM"] = "medium";
+  ImageSize2["LARGE"] = "large";
+  ImageSize2["EXTRA_LARGE"] = "extraLarge";
+  return ImageSize2;
+})(ImageSize || {});
+
+export { APIConnectionError, APIStatusError, ApiKeyAuth, AuthenticationError, BrowseContentFormat, BrowseResource, ClassicResource, ContentFormat, DEFAULT_SCOPE, DEFAULT_TIMEOUT, EntraIDAuth, HttpTransport, ImageAspectRatio, ImageColor, ImageSize, ImagesResource, NewsResource, PermissionDeniedError, RateLimitError, RetryPolicy, SafeSearch, SafeSearchMode, VideoDuration, VideoResolution, VideosResource, WebIQClient, WebIQError, WebResource, createAuth, createClient, createTelemetryEvent, safeCall };