@smoothbuilder/smoothagent-agent-server 0.0.0-stage → 0.3.0

package/dist/dashboard.js

@@ -0,0 +1,4227 @@
+import {
+  DEFAULT_BASE_URL
+} from "./chunk-C64SPUFX.js";
+import {
+  idempotencyHeaders
+} from "./chunk-T5FJM7CV.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// ../../generated/ts-dashboard/api/index.ts
+var api_exports = {};
+__export(api_exports, {
+  BadRequestError: () => BadRequestError,
+  ConflictError: () => ConflictError,
+  ForbiddenError: () => ForbiddenError,
+  InternalServerError: () => InternalServerError,
+  MembersRemoveResponse: () => MembersRemoveResponse,
+  NotFoundError: () => NotFoundError,
+  PlatformRun: () => PlatformRun,
+  Role: () => Role,
+  TooManyRequestsError: () => TooManyRequestsError,
+  UnauthorizedError: () => UnauthorizedError
+});
+
+// ../../generated/ts-dashboard/core/json.ts
+var toJson = (value, replacer, space) => {
+  return JSON.stringify(value, replacer, space);
+};
+function fromJson(text, reviver) {
+  return JSON.parse(text, reviver);
+}
+
+// ../../generated/ts-dashboard/errors/SmoothAgentDashboardError.ts
+var SmoothAgentDashboardError = class extends Error {
+  statusCode;
+  body;
+  rawResponse;
+  cause;
+  constructor({
+    message,
+    statusCode,
+    body,
+    rawResponse,
+    cause
+  }) {
+    super(buildMessage({ message, statusCode, body }));
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "SmoothAgentDashboardError";
+    this.statusCode = statusCode;
+    this.body = body;
+    this.rawResponse = rawResponse;
+    if (cause != null) {
+      this.cause = cause;
+    }
+  }
+  get requestId() {
+    const headers = this.rawResponse?.headers;
+    if (headers == null) {
+      return void 0;
+    }
+    const requestId = headers.get("X-Request-Id");
+    if (requestId != null) {
+      return requestId;
+    }
+    let fallback;
+    headers.forEach((value, name) => {
+      if (fallback === void 0 && /request[-_]?id$/i.test(name)) {
+        fallback = value;
+      }
+    });
+    return fallback;
+  }
+};
+function buildMessage({
+  message,
+  statusCode,
+  body
+}) {
+  const lines = [];
+  if (message != null) {
+    lines.push(message);
+  }
+  if (statusCode != null) {
+    lines.push(`Status code: ${statusCode.toString()}`);
+  }
+  if (body != null) {
+    lines.push(`Body: ${toJson(body, void 0, 2)}`);
+  }
+  return lines.join("\n");
+}
+
+// ../../generated/ts-dashboard/errors/SmoothAgentDashboardTimeoutError.ts
+var SmoothAgentDashboardTimeoutError = class extends SmoothAgentDashboardError {
+  constructor(message, opts) {
+    super({
+      message,
+      cause: opts?.cause
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "SmoothAgentDashboardTimeoutError";
+  }
+};
+
+// ../../generated/ts-dashboard/api/errors/BadRequestError.ts
+var BadRequestError = class extends SmoothAgentDashboardError {
+  constructor(body, rawResponse) {
+    super({
+      message: "BadRequestError",
+      statusCode: 400,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "BadRequestError";
+  }
+};
+
+// ../../generated/ts-dashboard/api/errors/ConflictError.ts
+var ConflictError = class extends SmoothAgentDashboardError {
+  constructor(body, rawResponse) {
+    super({
+      message: "ConflictError",
+      statusCode: 409,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "ConflictError";
+  }
+};
+
+// ../../generated/ts-dashboard/api/errors/ForbiddenError.ts
+var ForbiddenError = class extends SmoothAgentDashboardError {
+  constructor(body, rawResponse) {
+    super({
+      message: "ForbiddenError",
+      statusCode: 403,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "ForbiddenError";
+  }
+};
+
+// ../../generated/ts-dashboard/api/errors/InternalServerError.ts
+var InternalServerError = class extends SmoothAgentDashboardError {
+  constructor(body, rawResponse) {
+    super({
+      message: "InternalServerError",
+      statusCode: 500,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "InternalServerError";
+  }
+};
+
+// ../../generated/ts-dashboard/api/errors/NotFoundError.ts
+var NotFoundError = class extends SmoothAgentDashboardError {
+  constructor(body, rawResponse) {
+    super({
+      message: "NotFoundError",
+      statusCode: 404,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "NotFoundError";
+  }
+};
+
+// ../../generated/ts-dashboard/api/errors/TooManyRequestsError.ts
+var TooManyRequestsError = class extends SmoothAgentDashboardError {
+  constructor(body, rawResponse) {
+    super({
+      message: "TooManyRequestsError",
+      statusCode: 429,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "TooManyRequestsError";
+  }
+};
+
+// ../../generated/ts-dashboard/api/errors/UnauthorizedError.ts
+var UnauthorizedError = class extends SmoothAgentDashboardError {
+  constructor(body, rawResponse) {
+    super({
+      message: "UnauthorizedError",
+      statusCode: 401,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "UnauthorizedError";
+  }
+};
+
+// ../../generated/ts-dashboard/api/types/MembersRemoveResponse.ts
+var MembersRemoveResponse;
+((MembersRemoveResponse2) => {
+  let CreatedKeys;
+  ((CreatedKeys2) => {
+    let Item;
+    ((Item2) => {
+      Item2.Kind = {
+        Account: "account",
+        Workspace: "workspace",
+        Restricted: "restricted"
+      };
+    })(Item = CreatedKeys2.Item || (CreatedKeys2.Item = {}));
+  })(CreatedKeys = MembersRemoveResponse2.CreatedKeys || (MembersRemoveResponse2.CreatedKeys = {}));
+})(MembersRemoveResponse || (MembersRemoveResponse = {}));
+
+// ../../generated/ts-dashboard/api/types/PlatformRun.ts
+var PlatformRun;
+((PlatformRun2) => {
+  PlatformRun2.Status = {
+    Running: "running",
+    Completed: "completed",
+    Stopped: "stopped",
+    Failed: "failed"
+  };
+})(PlatformRun || (PlatformRun = {}));
+
+// ../../generated/ts-dashboard/api/types/Role.ts
+var Role = {
+  Owner: "owner",
+  Admin: "admin",
+  Member: "member"
+};
+
+// ../../generated/ts-dashboard/core/auth/AuthProvider.ts
+function isAuthProvider(value) {
+  return typeof value === "object" && value !== null && "getAuthRequest" in value && typeof value.getAuthRequest === "function";
+}
+
+// ../../generated/ts-dashboard/core/auth/NoOpAuthProvider.ts
+var NoOpAuthProvider = class {
+  getAuthRequest() {
+    return Promise.resolve({ headers: {} });
+  }
+};
+
+// ../../generated/ts-dashboard/core/fetcher/EndpointSupplier.ts
+var EndpointSupplier = {
+  get: async (supplier, arg) => {
+    if (typeof supplier === "function") {
+      return supplier(arg);
+    } else {
+      return supplier;
+    }
+  }
+};
+
+// ../../generated/ts-dashboard/core/logging/logger.ts
+var LogLevel = {
+  Debug: "debug",
+  Info: "info",
+  Warn: "warn",
+  Error: "error"
+};
+var logLevelMap = {
+  [LogLevel.Debug]: 1,
+  [LogLevel.Info]: 2,
+  [LogLevel.Warn]: 3,
+  [LogLevel.Error]: 4
+};
+var ConsoleLogger = class {
+  debug(message, ...args) {
+    console.debug(message, ...args);
+  }
+  info(message, ...args) {
+    console.info(message, ...args);
+  }
+  warn(message, ...args) {
+    console.warn(message, ...args);
+  }
+  error(message, ...args) {
+    console.error(message, ...args);
+  }
+};
+var Logger = class {
+  level;
+  logger;
+  silent;
+  /**
+   * Creates a new logger instance.
+   * @param config - Logger configuration
+   */
+  constructor(config) {
+    this.level = logLevelMap[config.level];
+    this.logger = config.logger;
+    this.silent = config.silent;
+  }
+  /**
+   * Checks if a log level should be output based on configuration.
+   * @param level - The log level to check
+   * @returns True if the level should be logged
+   */
+  shouldLog(level) {
+    return !this.silent && this.level <= logLevelMap[level];
+  }
+  /**
+   * Checks if debug logging is enabled.
+   * @returns True if debug logs should be output
+   */
+  isDebug() {
+    return this.shouldLog(LogLevel.Debug);
+  }
+  /**
+   * Logs a debug message if debug logging is enabled.
+   * @param message - The message to log
+   * @param args - Additional arguments to log
+   */
+  debug(message, ...args) {
+    if (this.isDebug()) {
+      this.logger.debug(message, ...args);
+    }
+  }
+  /**
+   * Checks if info logging is enabled.
+   * @returns True if info logs should be output
+   */
+  isInfo() {
+    return this.shouldLog(LogLevel.Info);
+  }
+  /**
+   * Logs an info message if info logging is enabled.
+   * @param message - The message to log
+   * @param args - Additional arguments to log
+   */
+  info(message, ...args) {
+    if (this.isInfo()) {
+      this.logger.info(message, ...args);
+    }
+  }
+  /**
+   * Checks if warning logging is enabled.
+   * @returns True if warning logs should be output
+   */
+  isWarn() {
+    return this.shouldLog(LogLevel.Warn);
+  }
+  /**
+   * Logs a warning message if warning logging is enabled.
+   * @param message - The message to log
+   * @param args - Additional arguments to log
+   */
+  warn(message, ...args) {
+    if (this.isWarn()) {
+      this.logger.warn(message, ...args);
+    }
+  }
+  /**
+   * Checks if error logging is enabled.
+   * @returns True if error logs should be output
+   */
+  isError() {
+    return this.shouldLog(LogLevel.Error);
+  }
+  /**
+   * Logs an error message if error logging is enabled.
+   * @param message - The message to log
+   * @param args - Additional arguments to log
+   */
+  error(message, ...args) {
+    if (this.isError()) {
+      this.logger.error(message, ...args);
+    }
+  }
+};
+function createLogger(config) {
+  if (config == null) {
+    return defaultLogger;
+  }
+  if (config instanceof Logger) {
+    return config;
+  }
+  config = config ?? {};
+  config.level ??= LogLevel.Info;
+  config.logger ??= new ConsoleLogger();
+  config.silent ??= true;
+  return new Logger(config);
+}
+var defaultLogger = new Logger({
+  level: LogLevel.Info,
+  logger: new ConsoleLogger(),
+  silent: true
+});
+
+// ../../generated/ts-dashboard/core/url/qs.ts
+var defaultQsOptions = {
+  arrayFormat: "indices",
+  encode: true
+};
+function encodeValue(value, shouldEncode) {
+  if (value === void 0) {
+    return "";
+  }
+  if (value === null) {
+    return "";
+  }
+  const stringValue = String(value);
+  return shouldEncode ? encodeURIComponent(stringValue) : stringValue;
+}
+function stringifyObject(obj, prefix = "", options) {
+  const parts = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}[${key}]` : key;
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        continue;
+      }
+      const effectiveFormat = options.arrayFormat;
+      if (effectiveFormat === "comma") {
+        const encodedKey = options.encode ? encodeURIComponent(fullKey) : fullKey;
+        const encodedValues = value.filter((item) => item !== void 0 && item !== null).map((item) => encodeValue(item, options.encode));
+        if (encodedValues.length > 0) {
+          parts.push(`${encodedKey}=${encodedValues.join(",")}`);
+        }
+      } else {
+        for (let i = 0; i < value.length; i++) {
+          const item = value[i];
+          if (item == null) {
+            continue;
+          }
+          if (typeof item === "object" && !Array.isArray(item) && item !== null) {
+            const arrayKey = effectiveFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+            parts.push(...stringifyObject(item, arrayKey, options));
+          } else {
+            const arrayKey = effectiveFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+            const encodedKey = options.encode ? encodeURIComponent(arrayKey) : arrayKey;
+            parts.push(`${encodedKey}=${encodeValue(item, options.encode)}`);
+          }
+        }
+      }
+    } else if (typeof value === "object" && value !== null) {
+      if (Object.keys(value).length === 0) {
+        continue;
+      }
+      parts.push(...stringifyObject(value, fullKey, options));
+    } else {
+      const encodedKey = options.encode ? encodeURIComponent(fullKey) : fullKey;
+      parts.push(`${encodedKey}=${encodeValue(value, options.encode)}`);
+    }
+  }
+  return parts;
+}
+function toQueryString(obj, options) {
+  if (obj == null || typeof obj !== "object") {
+    return "";
+  }
+  const parts = stringifyObject(obj, "", {
+    ...defaultQsOptions,
+    ...options
+  });
+  return parts.join("&");
+}
+
+// ../../generated/ts-dashboard/core/fetcher/createRequestUrl.ts
+function createRequestUrl(baseUrl, queryParameters) {
+  const queryString = toQueryString(queryParameters, { arrayFormat: "repeat" });
+  return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+}
+
+// ../../generated/ts-dashboard/core/fetcher/BinaryResponse.ts
+function getBinaryResponse(response) {
+  const binaryResponse = {
+    get bodyUsed() {
+      return response.bodyUsed;
+    },
+    stream: () => response.body,
+    arrayBuffer: response.arrayBuffer.bind(response),
+    blob: response.blob.bind(response)
+  };
+  if ("bytes" in response && typeof response.bytes === "function") {
+    binaryResponse.bytes = response.bytes.bind(response);
+  }
+  return binaryResponse;
+}
+
+// ../../generated/ts-dashboard/core/fetcher/getResponseBody.ts
+function retainResponse(target, response) {
+  Object.defineProperty(target, "__fern_response_ref", {
+    value: response,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+}
+var responseBodyErrors = /* @__PURE__ */ new WeakSet();
+function responseBodyError(error) {
+  const record = { ok: false, error };
+  responseBodyErrors.add(record);
+  return record;
+}
+function isResponseBodyError(value) {
+  return typeof value === "object" && value != null && responseBodyErrors.has(value);
+}
+async function getResponseBody(response, responseType) {
+  switch (responseType) {
+    case "binary-response":
+      return getBinaryResponse(response);
+    case "blob":
+      return await response.blob();
+    case "arrayBuffer":
+      return await response.arrayBuffer();
+    case "sse":
+      if (response.body == null) {
+        return responseBodyError({
+          reason: "body-is-null",
+          statusCode: response.status
+        });
+      }
+      retainResponse(response.body, response);
+      return response.body;
+    case "streaming":
+      if (response.body == null) {
+        return responseBodyError({
+          reason: "body-is-null",
+          statusCode: response.status
+        });
+      }
+      retainResponse(response.body, response);
+      return response.body;
+    case "text":
+      return await response.text();
+  }
+  const text = await response.text();
+  if (text.length > 0) {
+    try {
+      const responseBody = fromJson(text);
+      return responseBody;
+    } catch (_err) {
+      return responseBodyError({
+        reason: "non-json",
+        statusCode: response.status,
+        rawBody: text
+      });
+    }
+  }
+  return void 0;
+}
+
+// ../../generated/ts-dashboard/core/fetcher/getErrorResponseBody.ts
+function parseJsonErrorBody(text) {
+  if (text.length === 0) {
+    return void 0;
+  }
+  try {
+    return fromJson(text);
+  } catch {
+    return text;
+  }
+}
+async function getErrorResponseBody(response) {
+  let contentType = response.headers.get("Content-Type")?.toLowerCase();
+  if (contentType == null || contentType.length === 0) {
+    const body = await getResponseBody(response);
+    if (isResponseBodyError(body)) {
+      return body.error.reason === "non-json" ? body.error.rawBody : void 0;
+    }
+    return body;
+  }
+  if (contentType.indexOf(";") !== -1) {
+    contentType = contentType.split(";")[0]?.trim() ?? "";
+  }
+  switch (contentType) {
+    case "application/hal+json":
+    case "application/json":
+    case "application/ld+json":
+    case "application/problem+json":
+    case "application/vnd.api+json":
+    case "text/json":
+      return parseJsonErrorBody(await response.text());
+    default:
+      if (contentType.startsWith("application/vnd.") && contentType.endsWith("+json")) {
+        return parseJsonErrorBody(await response.text());
+      }
+      return await response.text();
+  }
+}
+
+// ../../generated/ts-dashboard/core/fetcher/getFetchFn.ts
+async function getFetchFn() {
+  return fetch;
+}
+
+// ../../generated/ts-dashboard/core/fetcher/getRequestBody.ts
+async function getRequestBody({ body, type }) {
+  if (type === "form") {
+    return toQueryString(body, { arrayFormat: "repeat", encode: true });
+  }
+  if (type.includes("json")) {
+    return toJson(body);
+  } else {
+    return body;
+  }
+}
+
+// ../../generated/ts-dashboard/core/fetcher/Headers.ts
+var Headers2;
+if (typeof globalThis.Headers !== "undefined") {
+  Headers2 = globalThis.Headers;
+} else {
+  Headers2 = class Headers3 {
+    headers;
+    constructor(init) {
+      this.headers = /* @__PURE__ */ new Map();
+      if (init) {
+        if (init instanceof Headers3) {
+          init.forEach((value, key) => this.append(key, value));
+        } else if (Array.isArray(init)) {
+          for (const [key, value] of init) {
+            if (typeof key === "string" && typeof value === "string") {
+              this.append(key, value);
+            } else {
+              throw new TypeError("Each header entry must be a [string, string] tuple");
+            }
+          }
+        } else {
+          for (const [key, value] of Object.entries(init)) {
+            if (typeof value === "string") {
+              this.append(key, value);
+            } else {
+              throw new TypeError("Header values must be strings");
+            }
+          }
+        }
+      }
+    }
+    append(name, value) {
+      const key = name.toLowerCase();
+      const existing = this.headers.get(key) || [];
+      this.headers.set(key, [...existing, value]);
+    }
+    delete(name) {
+      const key = name.toLowerCase();
+      this.headers.delete(key);
+    }
+    get(name) {
+      const key = name.toLowerCase();
+      const values = this.headers.get(key);
+      return values ? values.join(", ") : null;
+    }
+    has(name) {
+      const key = name.toLowerCase();
+      return this.headers.has(key);
+    }
+    set(name, value) {
+      const key = name.toLowerCase();
+      this.headers.set(key, [value]);
+    }
+    forEach(callbackfn, thisArg) {
+      const boundCallback = thisArg ? callbackfn.bind(thisArg) : callbackfn;
+      this.headers.forEach((values, key) => boundCallback(values.join(", "), key, this));
+    }
+    getSetCookie() {
+      return this.headers.get("set-cookie") || [];
+    }
+    *entries() {
+      for (const [key, values] of this.headers.entries()) {
+        yield [key, values.join(", ")];
+      }
+    }
+    *keys() {
+      yield* this.headers.keys();
+    }
+    *values() {
+      for (const values of this.headers.values()) {
+        yield values.join(", ");
+      }
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  };
+}
+
+// ../../generated/ts-dashboard/core/fetcher/signals.ts
+var TIMEOUT = "timeout";
+function getTimeoutSignal(timeoutMs) {
+  const controller = new AbortController();
+  const abortId = setTimeout(() => controller.abort(TIMEOUT), timeoutMs);
+  return { signal: controller.signal, abortId };
+}
+function anySignal(...args) {
+  const signals = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal?.reason);
+      return controller.signal;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal?.reason), {
+      signal: controller.signal
+    });
+    if (signal.aborted) {
+      controller.abort(signal?.reason);
+      return controller.signal;
+    }
+  }
+  return controller.signal;
+}
+
+// ../../generated/ts-dashboard/core/fetcher/makeRequest.ts
+var _cacheNoStoreSupported;
+function isCacheNoStoreSupported() {
+  if (_cacheNoStoreSupported != null) {
+    return _cacheNoStoreSupported;
+  }
+  try {
+    new Request("http://localhost", { cache: "no-store" });
+    _cacheNoStoreSupported = true;
+  } catch {
+    _cacheNoStoreSupported = false;
+  }
+  return _cacheNoStoreSupported;
+}
+var responseTimeouts = /* @__PURE__ */ new WeakMap();
+function clearResponseTimeout(response) {
+  const timeoutId = responseTimeouts.get(response);
+  if (timeoutId != null) {
+    clearTimeout(timeoutId);
+    responseTimeouts.delete(response);
+  }
+}
+var makeRequest = async (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex, disableCache, keepTimeoutUntilBodyRead) => {
+  const signals = [];
+  let timeoutAbortId;
+  let timeoutSignal;
+  if (timeoutMs != null) {
+    const { signal, abortId } = getTimeoutSignal(timeoutMs);
+    timeoutAbortId = abortId;
+    timeoutSignal = signal;
+    signals.push(signal);
+  }
+  if (abortSignal != null) {
+    signals.push(abortSignal);
+  }
+  const newSignals = anySignal(signals);
+  let response;
+  try {
+    response = await fetchFn(url, {
+      method,
+      headers,
+      body: requestBody,
+      signal: newSignals,
+      credentials: withCredentials ? "include" : void 0,
+      // @ts-ignore
+      duplex,
+      ...disableCache && isCacheNoStoreSupported() ? { cache: "no-store" } : {}
+    });
+  } catch (error) {
+    if (timeoutAbortId != null) {
+      clearTimeout(timeoutAbortId);
+    }
+    if (timeoutSignal?.aborted && !abortSignal?.aborted) {
+      throw TIMEOUT;
+    }
+    throw error;
+  }
+  if (timeoutAbortId != null) {
+    if (keepTimeoutUntilBodyRead) {
+      responseTimeouts.set(response, timeoutAbortId);
+    } else {
+      clearTimeout(timeoutAbortId);
+    }
+  }
+  return response;
+};
+
+// ../../generated/ts-dashboard/core/fetcher/RawResponse.ts
+var abortRawResponse = {
+  headers: new Headers2(),
+  redirected: false,
+  status: 499,
+  statusText: "Client Closed Request",
+  type: "error",
+  url: ""
+};
+var unknownRawResponse = {
+  headers: new Headers2(),
+  redirected: false,
+  status: 0,
+  statusText: "Unknown Error",
+  type: "error",
+  url: ""
+};
+function toRawResponse(response) {
+  return {
+    headers: response.headers,
+    redirected: response.redirected,
+    status: response.status,
+    statusText: response.statusText,
+    type: response.type,
+    url: response.url
+  };
+}
+
+// ../../generated/ts-dashboard/core/fetcher/redactUrl.ts
+var SENSITIVE_QUERY_PARAMS = /* @__PURE__ */ new Set([
+  "api_key",
+  "api-key",
+  "apikey",
+  "token",
+  "access_token",
+  "access-token",
+  "auth_token",
+  "auth-token",
+  "password",
+  "passwd",
+  "secret",
+  "api_secret",
+  "api-secret",
+  "apisecret",
+  "key",
+  "session",
+  "session_id",
+  "session-id"
+]);
+function redactUrl(url) {
+  const protocolIndex = url.indexOf("://");
+  if (protocolIndex === -1) return url;
+  const afterProtocol = protocolIndex + 3;
+  const pathStart = url.indexOf("/", afterProtocol);
+  let queryStart = url.indexOf("?", afterProtocol);
+  let fragmentStart = url.indexOf("#", afterProtocol);
+  const firstDelimiter = Math.min(
+    pathStart === -1 ? url.length : pathStart,
+    queryStart === -1 ? url.length : queryStart,
+    fragmentStart === -1 ? url.length : fragmentStart
+  );
+  let atIndex = -1;
+  for (let i = afterProtocol; i < firstDelimiter; i++) {
+    if (url[i] === "@") {
+      atIndex = i;
+    }
+  }
+  if (atIndex !== -1) {
+    url = `${url.slice(0, afterProtocol)}[REDACTED]@${url.slice(atIndex + 1)}`;
+  }
+  queryStart = url.indexOf("?");
+  if (queryStart === -1) return url;
+  fragmentStart = url.indexOf("#", queryStart);
+  const queryEnd = fragmentStart !== -1 ? fragmentStart : url.length;
+  const queryString = url.slice(queryStart + 1, queryEnd);
+  if (queryString.length === 0) return url;
+  const lower = queryString.toLowerCase();
+  const hasSensitive = lower.includes("token") || lower.includes("key") || lower.includes("password") || lower.includes("passwd") || lower.includes("secret") || lower.includes("session") || lower.includes("auth");
+  if (!hasSensitive) {
+    return url;
+  }
+  const redactedParams = [];
+  const params = queryString.split("&");
+  for (const param of params) {
+    const equalIndex = param.indexOf("=");
+    if (equalIndex === -1) {
+      redactedParams.push(param);
+      continue;
+    }
+    const key = param.slice(0, equalIndex);
+    let shouldRedact = SENSITIVE_QUERY_PARAMS.has(key.toLowerCase());
+    if (!shouldRedact && key.includes("%")) {
+      try {
+        const decodedKey = decodeURIComponent(key);
+        shouldRedact = SENSITIVE_QUERY_PARAMS.has(decodedKey.toLowerCase());
+      } catch {
+      }
+    }
+    redactedParams.push(shouldRedact ? `${key}=[REDACTED]` : param);
+  }
+  return url.slice(0, queryStart + 1) + redactedParams.join("&") + url.slice(queryEnd);
+}
+
+// ../../generated/ts-dashboard/core/fetcher/requestWithRetries.ts
+var INITIAL_RETRY_DELAY = 1e3;
+var MAX_RETRY_DELAY = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+var JITTER_FACTOR = 0.2;
+function isRetryableStatusCode(statusCode) {
+  return [408, 429].includes(statusCode) || statusCode >= 500;
+}
+function addPositiveJitter(delay) {
+  const jitterMultiplier = 1 + Math.random() * JITTER_FACTOR;
+  return delay * jitterMultiplier;
+}
+function addSymmetricJitter(delay) {
+  const jitterMultiplier = 1 + (Math.random() - 0.5) * JITTER_FACTOR;
+  return delay * jitterMultiplier;
+}
+function getRetryDelayFromHeaders(response, retryAttempt) {
+  const retryAfter = response.headers.get("Retry-After");
+  if (retryAfter) {
+    const retryAfterSeconds = parseInt(retryAfter, 10);
+    if (!Number.isNaN(retryAfterSeconds) && retryAfterSeconds > 0) {
+      return Math.min(retryAfterSeconds * 1e3, MAX_RETRY_DELAY);
+    }
+    const retryAfterDate = new Date(retryAfter);
+    if (!Number.isNaN(retryAfterDate.getTime())) {
+      const delay = retryAfterDate.getTime() - Date.now();
+      if (delay > 0) {
+        return Math.min(Math.max(delay, 0), MAX_RETRY_DELAY);
+      }
+    }
+  }
+  const rateLimitReset = response.headers.get("X-RateLimit-Reset");
+  if (rateLimitReset) {
+    const resetTime = parseInt(rateLimitReset, 10);
+    if (!Number.isNaN(resetTime)) {
+      const delay = resetTime * 1e3 - Date.now();
+      if (delay > 0) {
+        return addPositiveJitter(Math.min(delay, MAX_RETRY_DELAY));
+      }
+    }
+  }
+  return addSymmetricJitter(Math.min(INITIAL_RETRY_DELAY * 2 ** retryAttempt, MAX_RETRY_DELAY));
+}
+function sleep(ms, abortSignal) {
+  return new Promise((resolve, reject) => {
+    if (abortSignal?.aborted) {
+      reject(abortSignal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      reject(abortSignal?.reason);
+    };
+    const timeoutId = setTimeout(() => {
+      abortSignal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function requestWithRetries(requestFn, maxRetries = DEFAULT_MAX_RETRIES, abortSignal) {
+  let response = await requestFn();
+  for (let i = 0; i < maxRetries; ++i) {
+    if (isRetryableStatusCode(response.status)) {
+      const delay = getRetryDelayFromHeaders(response, i);
+      await sleep(delay, abortSignal);
+      response = await requestFn();
+    } else {
+      break;
+    }
+  }
+  return response;
+}
+
+// ../../generated/ts-dashboard/core/fetcher/Fetcher.ts
+var SENSITIVE_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "www-authenticate",
+  "x-api-key",
+  "api-key",
+  "apikey",
+  "x-api-token",
+  "x-auth-token",
+  "auth-token",
+  "cookie",
+  "set-cookie",
+  "proxy-authorization",
+  "proxy-authenticate",
+  "x-csrf-token",
+  "x-xsrf-token",
+  "x-session-token",
+  "x-access-token"
+]);
+function redactHeaders(headers) {
+  const filtered = {};
+  for (const [key, value] of headers instanceof Headers2 ? headers.entries() : Object.entries(headers)) {
+    if (SENSITIVE_HEADERS.has(key.toLowerCase())) {
+      filtered[key] = "[REDACTED]";
+    } else {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function redactQueryParameters(queryParameters) {
+  if (queryParameters == null) {
+    return void 0;
+  }
+  const redacted = {};
+  for (const [key, value] of Object.entries(queryParameters)) {
+    redacted[key] = SENSITIVE_QUERY_PARAMS.has(key.toLowerCase()) ? "[REDACTED]" : value;
+  }
+  return redacted;
+}
+async function getHeaders(args) {
+  const newHeaders = new Headers2();
+  newHeaders.set(
+    "Accept",
+    args.responseType === "json" ? "application/json" : args.responseType === "text" ? "text/plain" : args.responseType === "sse" ? "text/event-stream" : "*/*"
+  );
+  if (args.body !== void 0 && args.contentType != null) {
+    newHeaders.set("Content-Type", args.contentType);
+  }
+  if (args.headers == null) {
+    return newHeaders;
+  }
+  for (const [key, value] of Object.entries(args.headers)) {
+    const result = await EndpointSupplier.get(value, { endpointMetadata: args.endpointMetadata ?? {} });
+    if (typeof result === "string") {
+      newHeaders.set(key, result);
+      continue;
+    }
+    if (result == null) {
+      continue;
+    }
+    newHeaders.set(key, `${result}`);
+  }
+  return newHeaders;
+}
+function isJsonContentType(contentType) {
+  const mediaType = contentType?.split(";")[0]?.trim().toLowerCase() ?? "";
+  return mediaType === "application/json" || mediaType === "text/json" || mediaType.endsWith("+json");
+}
+async function fetcherImpl(args) {
+  let url = args.url;
+  if (args.queryString != null && args.queryString.length > 0) {
+    url = `${url}?${args.queryString}`;
+  } else {
+    url = createRequestUrl(args.url, args.queryParameters);
+  }
+  const requestBody = await getRequestBody({
+    body: args.body,
+    type: args.requestType ?? "other"
+  });
+  const fetchFn = args.fetchFn ?? await getFetchFn();
+  const headers = await getHeaders(args);
+  const logger = createLogger(args.logging);
+  if (logger.isDebug()) {
+    const metadata = {
+      method: args.method,
+      url: redactUrl(url),
+      headers: redactHeaders(headers),
+      queryParameters: redactQueryParameters(args.queryParameters),
+      hasBody: requestBody != null
+    };
+    logger.debug("Making HTTP request", metadata);
+  }
+  const keepTimeoutUntilBodyRead = args.responseType !== "streaming" && args.responseType !== "sse" && args.responseType !== "binary-response";
+  const attemptResponses = [];
+  try {
+    const response = await requestWithRetries(
+      async () => {
+        for (const previousResponse of attemptResponses) {
+          clearResponseTimeout(previousResponse);
+        }
+        const attemptResponse = await makeRequest(
+          fetchFn,
+          url,
+          args.method,
+          headers,
+          requestBody,
+          args.timeoutMs,
+          args.abortSignal,
+          args.withCredentials,
+          args.duplex,
+          args.responseType === "streaming" || args.responseType === "sse",
+          keepTimeoutUntilBodyRead
+        );
+        attemptResponses.push(attemptResponse);
+        return attemptResponse;
+      },
+      args.maxRetries,
+      args.abortSignal
+    );
+    if (response.status >= 200 && response.status < 400) {
+      if (logger.isDebug()) {
+        const metadata = {
+          method: args.method,
+          url: redactUrl(url),
+          statusCode: response.status,
+          responseHeaders: redactHeaders(response.headers)
+        };
+        logger.debug("HTTP request succeeded", metadata);
+      }
+      const body = await getResponseBody(response, args.responseType);
+      if (isResponseBodyError(body) && body.error.reason === "non-json" && isJsonContentType(response.headers.get("Content-Type"))) {
+        return {
+          ok: false,
+          error: body.error,
+          rawResponse: toRawResponse(response)
+        };
+      }
+      return {
+        ok: true,
+        body,
+        headers: response.headers,
+        rawResponse: toRawResponse(response)
+      };
+    } else {
+      if (logger.isError()) {
+        const metadata = {
+          method: args.method,
+          url: redactUrl(url),
+          statusCode: response.status,
+          responseHeaders: redactHeaders(Object.fromEntries(response.headers.entries()))
+        };
+        logger.error("HTTP request failed with error status", metadata);
+      }
+      return {
+        ok: false,
+        error: {
+          reason: "status-code",
+          statusCode: response.status,
+          body: await getErrorResponseBody(response)
+        },
+        rawResponse: toRawResponse(response)
+      };
+    }
+  } catch (error) {
+    if (args.abortSignal?.aborted) {
+      if (logger.isError()) {
+        const metadata = {
+          method: args.method,
+          url: redactUrl(url)
+        };
+        logger.error("HTTP request was aborted", metadata);
+      }
+      return {
+        ok: false,
+        error: {
+          reason: "unknown",
+          errorMessage: "The user aborted a request",
+          cause: error
+        },
+        rawResponse: abortRawResponse
+      };
+    } else if (error === TIMEOUT || error instanceof Error && error.name === "AbortError") {
+      if (logger.isError()) {
+        const metadata = {
+          method: args.method,
+          url: redactUrl(url),
+          timeoutMs: args.timeoutMs
+        };
+        logger.error("HTTP request timed out", metadata);
+      }
+      return {
+        ok: false,
+        error: {
+          reason: "timeout",
+          cause: error
+        },
+        rawResponse: abortRawResponse
+      };
+    } else if (error instanceof Error) {
+      if (logger.isError()) {
+        const metadata = {
+          method: args.method,
+          url: redactUrl(url),
+          errorMessage: error.message
+        };
+        logger.error("HTTP request failed with error", metadata);
+      }
+      return {
+        ok: false,
+        error: {
+          reason: "unknown",
+          errorMessage: error.message,
+          cause: error
+        },
+        rawResponse: unknownRawResponse
+      };
+    }
+    if (logger.isError()) {
+      const metadata = {
+        method: args.method,
+        url: redactUrl(url),
+        error: toJson(error)
+      };
+      logger.error("HTTP request failed with unknown error", metadata);
+    }
+    return {
+      ok: false,
+      error: {
+        reason: "unknown",
+        errorMessage: toJson(error),
+        cause: error
+      },
+      rawResponse: unknownRawResponse
+    };
+  } finally {
+    for (const attemptResponse of attemptResponses) {
+      clearResponseTimeout(attemptResponse);
+    }
+  }
+}
+var fetcher = fetcherImpl;
+
+// ../../generated/ts-dashboard/core/fetcher/HttpResponsePromise.ts
+var HttpResponsePromise = class _HttpResponsePromise extends Promise {
+  innerPromise;
+  unwrappedPromise;
+  constructor(promise) {
+    super((resolve) => {
+      resolve(void 0);
+    });
+    this.innerPromise = promise;
+  }
+  /**
+   * Creates an `HttpResponsePromise` from a function that returns a promise.
+   *
+   * @param fn - A function that returns a promise resolving to a `WithRawResponse` object.
+   * @param args - Arguments to pass to the function.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromFunction(fn, ...args) {
+    return new _HttpResponsePromise(fn(...args));
+  }
+  /**
+   * Creates a function that returns an `HttpResponsePromise` from a function that returns a promise.
+   *
+   * @param fn - A function that returns a promise resolving to a `WithRawResponse` object.
+   * @returns A function that returns an `HttpResponsePromise` instance.
+   */
+  static interceptFunction(fn) {
+    return (...args) => {
+      return _HttpResponsePromise.fromPromise(fn(...args));
+    };
+  }
+  /**
+   * Creates an `HttpResponsePromise` from an existing promise.
+   *
+   * @param promise - A promise resolving to a `WithRawResponse` object.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromPromise(promise) {
+    return new _HttpResponsePromise(promise);
+  }
+  /**
+   * Creates an `HttpResponsePromise` from an executor function.
+   *
+   * @param executor - A function that takes resolve and reject callbacks to create a promise.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromExecutor(executor) {
+    const promise = new Promise(executor);
+    return new _HttpResponsePromise(promise);
+  }
+  /**
+   * Creates an `HttpResponsePromise` from a resolved result.
+   *
+   * @param result - A `WithRawResponse` object to resolve immediately.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromResult(result) {
+    const promise = Promise.resolve(result);
+    return new _HttpResponsePromise(promise);
+  }
+  unwrap() {
+    if (!this.unwrappedPromise) {
+      this.unwrappedPromise = this.innerPromise.then(({ data }) => data);
+    }
+    return this.unwrappedPromise;
+  }
+  /** @inheritdoc */
+  then(onfulfilled, onrejected) {
+    return this.unwrap().then(onfulfilled, onrejected);
+  }
+  /** @inheritdoc */
+  catch(onrejected) {
+    return this.unwrap().catch(onrejected);
+  }
+  /** @inheritdoc */
+  finally(onfinally) {
+    return this.unwrap().finally(onfinally);
+  }
+  /**
+   * Retrieves the data and raw response.
+   *
+   * @returns A promise resolving to a `WithRawResponse` object.
+   */
+  async withRawResponse() {
+    return await this.innerPromise;
+  }
+};
+
+// ../../generated/ts-dashboard/core/url/join.ts
+function join(base, ...segments) {
+  if (!base) {
+    return "";
+  }
+  if (segments.length === 0) {
+    return base;
+  }
+  if (base.includes("://")) {
+    let url;
+    try {
+      url = new URL(base);
+    } catch {
+      return joinPath(base, ...segments);
+    }
+    const lastSegment = segments[segments.length - 1];
+    const shouldPreserveTrailingSlash = lastSegment?.endsWith("/");
+    for (const segment of segments) {
+      const cleanSegment = trimSlashes(segment);
+      if (cleanSegment) {
+        url.pathname = joinPathSegments(url.pathname, cleanSegment);
+      }
+    }
+    if (shouldPreserveTrailingSlash && !url.pathname.endsWith("/")) {
+      url.pathname += "/";
+    }
+    return url.toString();
+  }
+  return joinPath(base, ...segments);
+}
+function joinPath(base, ...segments) {
+  if (segments.length === 0) {
+    return base;
+  }
+  let result = base;
+  const lastSegment = segments[segments.length - 1];
+  const shouldPreserveTrailingSlash = lastSegment?.endsWith("/");
+  for (const segment of segments) {
+    const cleanSegment = trimSlashes(segment);
+    if (cleanSegment) {
+      result = joinPathSegments(result, cleanSegment);
+    }
+  }
+  if (shouldPreserveTrailingSlash && !result.endsWith("/")) {
+    result += "/";
+  }
+  return result;
+}
+function joinPathSegments(left, right) {
+  if (left.endsWith("/")) {
+    return left + right;
+  }
+  return `${left}/${right}`;
+}
+function trimSlashes(str) {
+  if (!str) return str;
+  let start = 0;
+  let end = str.length;
+  if (str.startsWith("/")) start = 1;
+  if (str.endsWith("/")) end = str.length - 1;
+  return start === 0 && end === str.length ? str : str.slice(start, end);
+}
+
+// ../../generated/ts-dashboard/core/fetcher/Supplier.ts
+var Supplier = {
+  get: async (supplier) => {
+    if (typeof supplier === "function") {
+      return supplier();
+    } else {
+      return supplier;
+    }
+  }
+};
+
+// ../../generated/ts-dashboard/core/fetcher/makePassthroughRequest.ts
+async function makePassthroughRequest(input, init, clientOptions, requestOptions) {
+  const logger = createLogger(clientOptions.logging);
+  let url;
+  let effectiveInit = init;
+  if (input instanceof Request) {
+    url = input.url;
+    if (init == null) {
+      effectiveInit = {
+        method: input.method,
+        headers: Object.fromEntries(input.headers.entries()),
+        body: input.body,
+        signal: input.signal,
+        credentials: input.credentials,
+        cache: input.cache,
+        redirect: input.redirect,
+        referrer: input.referrer,
+        integrity: input.integrity,
+        mode: input.mode
+      };
+    }
+  } else {
+    url = input instanceof URL ? input.toString() : input;
+  }
+  const baseUrl = (clientOptions.baseUrl != null ? await Supplier.get(clientOptions.baseUrl) : void 0) ?? (clientOptions.environment != null ? await Supplier.get(clientOptions.environment) : void 0);
+  let fullUrl;
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    fullUrl = url;
+  } else if (baseUrl != null) {
+    fullUrl = join(baseUrl, url);
+  } else {
+    fullUrl = url;
+  }
+  const mergedHeaders = {};
+  if (clientOptions.headers != null) {
+    for (const [key, value] of Object.entries(clientOptions.headers)) {
+      const resolved = await EndpointSupplier.get(value, { endpointMetadata: {} });
+      if (resolved != null) {
+        mergedHeaders[key.toLowerCase()] = `${resolved}`;
+      }
+    }
+  }
+  if (clientOptions.getAuthHeaders != null && targetsBaseUrl(fullUrl, baseUrl)) {
+    const authHeaders = await clientOptions.getAuthHeaders();
+    for (const [key, value] of Object.entries(authHeaders)) {
+      mergedHeaders[key.toLowerCase()] = value;
+    }
+  }
+  if (effectiveInit?.headers != null) {
+    const initHeaders = effectiveInit.headers instanceof Headers ? Object.fromEntries(effectiveInit.headers.entries()) : Array.isArray(effectiveInit.headers) ? Object.fromEntries(effectiveInit.headers) : effectiveInit.headers;
+    for (const [key, value] of Object.entries(initHeaders)) {
+      if (value != null) {
+        mergedHeaders[key.toLowerCase()] = value;
+      }
+    }
+  }
+  if (requestOptions?.headers != null) {
+    for (const [key, value] of Object.entries(requestOptions.headers)) {
+      mergedHeaders[key.toLowerCase()] = value;
+    }
+  }
+  const method = effectiveInit?.method ?? "GET";
+  const body = effectiveInit?.body;
+  const timeoutInSeconds = requestOptions?.timeoutInSeconds ?? clientOptions.timeoutInSeconds;
+  const timeoutMs = timeoutInSeconds != null ? timeoutInSeconds * 1e3 : void 0;
+  const maxRetries = requestOptions?.maxRetries ?? clientOptions.maxRetries;
+  const abortSignal = requestOptions?.abortSignal ?? effectiveInit?.signal ?? void 0;
+  const fetchFn = clientOptions.fetch ?? await getFetchFn();
+  if (logger.isDebug()) {
+    logger.debug("Making passthrough HTTP request", {
+      method,
+      url: redactUrl(fullUrl),
+      hasBody: body != null
+    });
+  }
+  let response;
+  try {
+    response = await requestWithRetries(
+      async () => makeRequest(
+        fetchFn,
+        fullUrl,
+        method,
+        mergedHeaders,
+        body ?? void 0,
+        timeoutMs,
+        abortSignal,
+        effectiveInit?.credentials === "include",
+        void 0,
+        // duplex
+        false
+        // disableCache
+      ),
+      maxRetries,
+      abortSignal
+    );
+  } catch (error) {
+    if (error === TIMEOUT) {
+      throw createTimeoutError();
+    }
+    throw error;
+  }
+  if (logger.isDebug()) {
+    logger.debug("Passthrough HTTP request completed", {
+      method,
+      url: redactUrl(fullUrl),
+      statusCode: response.status
+    });
+  }
+  return response;
+}
+function createTimeoutError() {
+  const error = new Error("The request timed out.");
+  error.name = "TimeoutError";
+  return error;
+}
+function targetsBaseUrl(fullUrl, baseUrl) {
+  if (baseUrl == null) {
+    return false;
+  }
+  try {
+    return new URL(fullUrl).origin === new URL(baseUrl).origin;
+  } catch {
+    return false;
+  }
+}
+
+// ../../generated/ts-dashboard/core/logging/index.ts
+var logging_exports = {};
+__export(logging_exports, {
+  ConsoleLogger: () => ConsoleLogger,
+  LogLevel: () => LogLevel,
+  Logger: () => Logger,
+  createLogger: () => createLogger
+});
+
+// ../../generated/ts-dashboard/core/pagination/Page.ts
+var Page = class {
+  data;
+  rawResponse;
+  response;
+  _hasNextPage;
+  getItems;
+  loadNextPage;
+  constructor({
+    response,
+    rawResponse,
+    hasNextPage,
+    getItems,
+    loadPage
+  }) {
+    this.response = response;
+    this.rawResponse = rawResponse;
+    this.data = getItems(response);
+    this._hasNextPage = hasNextPage;
+    this.getItems = getItems;
+    this.loadNextPage = loadPage;
+  }
+  /**
+   * Retrieves the next page
+   * @returns this
+   */
+  async getNextPage() {
+    const { data, rawResponse } = await this.loadNextPage(this.response).withRawResponse();
+    this.response = data;
+    this.rawResponse = rawResponse;
+    this.data = this.getItems(this.response);
+    return this;
+  }
+  /**
+   * @returns whether there is a next page to load
+   */
+  hasNextPage() {
+    return this._hasNextPage(this.response);
+  }
+  async *iterMessages() {
+    for (const item of this.data) {
+      yield item;
+    }
+    while (this.hasNextPage()) {
+      await this.getNextPage();
+      for (const item of this.data) {
+        yield item;
+      }
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const message of this.iterMessages()) {
+      yield message;
+    }
+  }
+};
+
+// ../../generated/ts-dashboard/core/runtime/runtime.ts
+var RUNTIME = evaluateRuntime();
+function evaluateRuntime() {
+  const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+  if (isBrowser) {
+    return {
+      type: "browser",
+      version: window.navigator.userAgent
+    };
+  }
+  const isCloudflare = typeof globalThis !== "undefined" && globalThis?.navigator?.userAgent === "Cloudflare-Workers";
+  if (isCloudflare) {
+    return {
+      type: "workerd"
+    };
+  }
+  const isEdgeRuntime = typeof EdgeRuntime === "string";
+  if (isEdgeRuntime) {
+    return {
+      type: "edge-runtime"
+    };
+  }
+  const isWebWorker = typeof self === "object" && typeof self?.importScripts === "function" && (self.constructor?.name === "DedicatedWorkerGlobalScope" || self.constructor?.name === "ServiceWorkerGlobalScope" || self.constructor?.name === "SharedWorkerGlobalScope");
+  if (isWebWorker) {
+    return {
+      type: "web-worker"
+    };
+  }
+  const isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined";
+  if (isDeno) {
+    return {
+      type: "deno",
+      version: Deno.version.deno,
+      os: Deno.build?.os,
+      arch: Deno.build?.arch
+    };
+  }
+  const isBun = typeof Bun !== "undefined" && typeof Bun.version !== "undefined";
+  if (isBun) {
+    return {
+      type: "bun",
+      version: Bun.version,
+      os: typeof process !== "undefined" ? process.platform : void 0,
+      arch: typeof process !== "undefined" ? process.arch : void 0
+    };
+  }
+  const isReactNative = typeof navigator !== "undefined" && navigator?.product === "ReactNative";
+  if (isReactNative) {
+    return {
+      type: "react-native"
+    };
+  }
+  const _process = typeof process !== "undefined" ? process : void 0;
+  const isNode = typeof _process !== "undefined" && typeof _process.versions?.node === "string";
+  if (isNode) {
+    return {
+      type: "node",
+      version: _process.versions.node,
+      parsedVersion: Number(_process.versions.node.split(".")[0]),
+      os: _process.platform,
+      arch: _process.arch
+    };
+  }
+  return {
+    type: "unknown"
+  };
+}
+
+// ../../generated/ts-dashboard/core/url/index.ts
+var url_exports = {};
+__export(url_exports, {
+  encodePathParam: () => encodePathParam,
+  join: () => join,
+  queryBuilder: () => queryBuilder,
+  toQueryString: () => toQueryString
+});
+
+// ../../generated/ts-dashboard/core/url/encodePathParam.ts
+function encodePathParam(param, InvalidPathParameterError) {
+  if (param === null) {
+    return "null";
+  }
+  const typeofParam = typeof param;
+  switch (typeofParam) {
+    case "undefined":
+      return "undefined";
+    case "string":
+    case "number":
+    case "boolean":
+      break;
+    default:
+      param = String(param);
+      break;
+  }
+  const encoded = encodeURIComponent(param);
+  if (encoded === "." || encoded === "..") {
+    const message = `Invalid path parameter "${encoded}": "." and ".." are not allowed because they change the request path.`;
+    throw InvalidPathParameterError != null ? new InvalidPathParameterError({ message }) : new Error(message);
+  }
+  return encoded;
+}
+
+// ../../generated/ts-dashboard/core/url/QueryStringBuilder.ts
+function queryBuilder() {
+  return new QueryStringBuilder();
+}
+var QueryStringBuilder = class {
+  parts = /* @__PURE__ */ new Map();
+  /**
+   * Adds a query parameter, serializing it immediately.
+   *
+   * By default arrays use "repeat" format (`key=a&key=b`).
+   * Pass `{ style: "comma" }` for OpenAPI `explode: false` parameters
+   * to get comma-separated values (`key=a,b,c`).
+   *
+   * Null / undefined values are silently skipped.
+   */
+  add(key, value, options) {
+    if (value === void 0 || value === null) {
+      return this;
+    }
+    const serialized = toQueryString(
+      { [key]: value },
+      { arrayFormat: options?.style === "comma" ? "comma" : "repeat" }
+    );
+    if (serialized.length > 0) {
+      this.parts.set(key, serialized);
+    }
+    return this;
+  }
+  /**
+   * Adds multiple query parameters at once from a record.
+   * All parameters use the default "repeat" array format.
+   * Null / undefined values are silently skipped.
+   */
+  addMany(params) {
+    if (params != null) {
+      for (const [key, value] of Object.entries(params)) {
+        this.add(key, value);
+      }
+    }
+    return this;
+  }
+  /**
+   * Merges additional query parameters supplied at call-time via
+   * `requestOptions.queryParams`. Overrides existing keys (last-write-wins).
+   */
+  mergeAdditional(additionalParams) {
+    if (additionalParams != null) {
+      for (const [key, value] of Object.entries(additionalParams)) {
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        const serialized = toQueryString({ [key]: value }, { arrayFormat: "repeat" });
+        if (serialized.length > 0) {
+          this.parts.set(key, serialized);
+        }
+      }
+    }
+    return this;
+  }
+  /**
+   * Returns the assembled query string (without the leading `?`).
+   * Returns an empty string when no parameters were added.
+   */
+  build() {
+    return [...this.parts.values()].join("&");
+  }
+};
+
+// ../../generated/ts-dashboard/core/utils/setObjectProperty.ts
+function setObjectProperty(object, path, value) {
+  if (object == null) {
+    return object;
+  }
+  const keys = path.split(".");
+  if (keys.length === 0) {
+    return object;
+  }
+  const result = { ...object };
+  let current = result;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (key == null) {
+      continue;
+    }
+    const next = current[key];
+    if (Array.isArray(next)) {
+      current[key] = [...next];
+    } else {
+      current[key] = next != null && typeof next === "object" ? { ...next } : {};
+    }
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  if (lastKey == null) {
+    return result;
+  }
+  current[lastKey] = value;
+  return result;
+}
+
+// ../../generated/ts-dashboard/auth/BearerAuthProvider.ts
+var TOKEN_PARAM = "token";
+var BearerAuthProvider = class _BearerAuthProvider {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  static canCreate(options) {
+    return options?.[TOKEN_PARAM] != null;
+  }
+  async getAuthRequest({
+    endpointMetadata
+  } = {}) {
+    const token = await Supplier.get(this.options[TOKEN_PARAM]);
+    if (token == null) {
+      throw new SmoothAgentDashboardError({
+        message: _BearerAuthProvider.AUTH_CONFIG_ERROR_MESSAGE
+      });
+    }
+    return {
+      headers: { Authorization: `Bearer ${token}` }
+    };
+  }
+};
+((BearerAuthProvider2) => {
+  BearerAuthProvider2.AUTH_SCHEME = "BearerAuth";
+  BearerAuthProvider2.AUTH_CONFIG_ERROR_MESSAGE = `Please provide '${TOKEN_PARAM}' when initializing the client`;
+  function createInstance(options) {
+    return new BearerAuthProvider2(options);
+  }
+  BearerAuthProvider2.createInstance = createInstance;
+})(BearerAuthProvider || (BearerAuthProvider = {}));
+
+// ../../generated/ts-dashboard/core/headers.ts
+function mergeHeaders(...headersArray) {
+  const result = {};
+  for (const [key, value] of headersArray.filter((headers) => headers != null).flatMap((headers) => Object.entries(headers))) {
+    const insensitiveKey = key.toLowerCase();
+    if (value != null) {
+      result[insensitiveKey] = value;
+    } else if (insensitiveKey in result) {
+      delete result[insensitiveKey];
+    }
+  }
+  return result;
+}
+function mergeOnlyDefinedHeaders(...headersArray) {
+  const result = {};
+  for (const [key, value] of headersArray.filter((headers) => headers != null).flatMap((headers) => Object.entries(headers))) {
+    const insensitiveKey = key.toLowerCase();
+    if (value != null) {
+      result[insensitiveKey] = value;
+    }
+  }
+  return result;
+}
+
+// ../../generated/ts-dashboard/BaseClient.ts
+function normalizeClientOptions(options) {
+  const headers = mergeHeaders(
+    {
+      "X-Fern-Language": "JavaScript",
+      "X-Fern-Runtime": RUNTIME.type,
+      "X-Fern-Runtime-Version": RUNTIME.version
+    },
+    options?.headers
+  );
+  return {
+    ...options,
+    logging: logging_exports.createLogger(options?.logging),
+    headers
+  };
+}
+function normalizeClientOptionsWithAuth(options) {
+  const normalized = normalizeClientOptions(options);
+  if (options.auth === false) {
+    normalized.authProvider = new NoOpAuthProvider();
+    return normalized;
+  }
+  if (options.auth != null) {
+    if (typeof options.auth === "function") {
+      normalized.authProvider = { getAuthRequest: options.auth };
+      return normalized;
+    }
+    if (isAuthProvider(options.auth)) {
+      normalized.authProvider = options.auth;
+      return normalized;
+    }
+    Object.assign(normalized, options.auth);
+  }
+  const normalizedWithNoOpAuthProvider = withNoOpAuthProvider(normalized);
+  normalized.authProvider ??= new BearerAuthProvider(normalizedWithNoOpAuthProvider);
+  return normalized;
+}
+function withNoOpAuthProvider(options) {
+  return {
+    ...options,
+    authProvider: new NoOpAuthProvider()
+  };
+}
+
+// ../../generated/ts-dashboard/core/requestBody.ts
+function mergeAdditionalBodyParameters(body, additionalBodyParameters) {
+  if (additionalBodyParameters == null) {
+    return body;
+  }
+  if (body == null) {
+    return { ...additionalBodyParameters };
+  }
+  if (typeof body === "object" && !Array.isArray(body)) {
+    return { ...body, ...additionalBodyParameters };
+  }
+  return body;
+}
+
+// ../../generated/ts-dashboard/environments.ts
+var SmoothAgentDashboardEnvironment = {
+  Default: "https://smoothagent-v3-api.uaibuilder.workers.dev"
+};
+
+// ../../generated/ts-dashboard/errors/handleNonStatusCodeError.ts
+function handleNonStatusCodeError(error, rawResponse, method, path) {
+  switch (error.reason) {
+    case "non-json":
+      throw new SmoothAgentDashboardError({
+        statusCode: error.statusCode,
+        body: error.rawBody,
+        rawResponse
+      });
+    case "body-is-null":
+      throw new SmoothAgentDashboardError({
+        statusCode: error.statusCode,
+        rawResponse
+      });
+    case "timeout":
+      throw new SmoothAgentDashboardTimeoutError(`Timeout exceeded when calling ${method} ${path}.`, {
+        cause: error.cause
+      });
+    case "unknown":
+      throw new SmoothAgentDashboardError({
+        message: error.errorMessage,
+        rawResponse,
+        cause: error.cause
+      });
+    default:
+      throw new SmoothAgentDashboardError({
+        message: "Unknown error",
+        rawResponse
+      });
+  }
+}
+
+// ../../generated/ts-dashboard/Client.ts
+var SmoothAgentDashboardClient = class {
+  _options;
+  constructor(options = {}) {
+    this._options = normalizeClientOptionsWithAuth(options);
+  }
+  /**
+   * Organização nova: o login vira owner e a sessão já abre nela. Pela sessão, ou por `email`+`password` (quem saiu de todas). Até 20 por login (409 `too_many_accounts`, também no aceite de convite).
+   *
+   * @param {SmoothAgentDashboard.DashboardAuthCreateAccountRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthCreateAccount({
+   *         name: "name"
+   *     })
+   */
+  dashboardAuthCreateAccount(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthCreateAccount(request, requestOptions));
+  }
+  async __dashboardAuthCreateAccount(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _headers = mergeHeaders(
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/accounts"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/auth/accounts");
+  }
+  /**
+   * O token de USUÁRIO do workspace nativo pro membro logado — entra no workspace e ganha o grant no
+   * Assistente na 1ª vez. Só sessão do dashboard (403 `not_dashboard_session` pra chave de API colada);
+   * Assistente fora do ambiente: 500 `internal` `{reason: "assistant_unavailable"}`.
+   *
+   * @param {SmoothAgentDashboard.DashboardAuthAssistantTokenRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthAssistantToken()
+   */
+  dashboardAuthAssistantToken(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthAssistantToken(request, requestOptions));
+  }
+  async __dashboardAuthAssistantToken(request = {}, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/assistant/token"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/auth/assistant/token");
+  }
+  /**
+   * Esqueci a senha: código de uso único (30 min) pro e-mail. Responde 202 exista ou não a conta.
+   * Sem e-mail de saída no ambiente: 500 `internal` `{reason: "mail_not_configured"}` (nunca finge).
+   *
+   * @param {SmoothAgentDashboard.DashboardAuthForgotRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthForgot({
+   *         email: "email"
+   *     })
+   */
+  dashboardAuthForgot(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthForgot(request, requestOptions));
+  }
+  async __dashboardAuthForgot(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _headers = mergeHeaders(
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/forgot"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/auth/forgot");
+  }
+  /**
+   * Aceita (uso único). COM sessão: o e-mail dela tem que ser o do convite (403 `invite_email_mismatch`). SEM sessão:
+   * e-mail com login = a `password` dele (com a trava do login); sem login = o login nasce com a `password` (≥ 10).
+   * Inválido/vencido/usado/revogado = 400 `{reason: "invalid_invite"}`. A sessão já abre na conta do convite.
+   *
+   * @param {SmoothAgentDashboard.DashboardAuthAcceptInviteRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthAcceptInvite({
+   *         token: "token"
+   *     })
+   */
+  dashboardAuthAcceptInvite(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthAcceptInvite(request, requestOptions));
+  }
+  async __dashboardAuthAcceptInvite(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _headers = mergeHeaders(
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/invites/accept"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/auth/invites/accept");
+  }
+  /**
+   * A tela de aceite: de que conta é o convite. Inválido/vencido/usado/revogado = 400 `{reason: "invalid_invite"}` (a mesma resposta).
+   *
+   * @param {SmoothAgentDashboard.DashboardAuthLookupInviteRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthLookupInvite({
+   *         token: "token"
+   *     })
+   */
+  dashboardAuthLookupInvite(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthLookupInvite(request, requestOptions));
+  }
+  async __dashboardAuthLookupInvite(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _headers = mergeHeaders(
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/invites/lookup"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/auth/invites/lookup");
+  }
+  /**
+   * 5 erros seguidos travam por 15 min (`rate_limited`); nunca diz se o e-mail existe. A sessão abre na `accountId`
+   * pedida (tem que ser membro; senão 404) ou na conta ATIVA (a do último login/troca).
+   *
+   * @param {SmoothAgentDashboard.DashboardAuthLoginRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthLogin({
+   *         email: "email",
+   *         password: "password"
+   *     })
+   */
+  dashboardAuthLogin(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthLogin(request, requestOptions));
+  }
+  async __dashboardAuthLogin(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _headers = mergeHeaders(
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/login"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/auth/login");
+  }
+  /**
+   * @param {SmoothAgentDashboard.DashboardAuthLogoutRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthLogout()
+   */
+  dashboardAuthLogout(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthLogout(request, requestOptions));
+  }
+  async __dashboardAuthLogout(request = {}, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/logout"
+      ),
+      method: "POST",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/auth/logout");
+  }
+  /**
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthMe()
+   */
+  dashboardAuthMe(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthMe(requestOptions));
+  }
+  async __dashboardAuthMe(requestOptions) {
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/me"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v3/auth/me");
+  }
+  /**
+   * @param {SmoothAgentDashboard.DashboardAuthChangePasswordRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthChangePassword({
+   *         currentPassword: "currentPassword",
+   *         newPassword: "newPassword"
+   *     })
+   */
+  dashboardAuthChangePassword(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthChangePassword(request, requestOptions));
+  }
+  async __dashboardAuthChangePassword(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/password"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/auth/password");
+  }
+  /**
+   * Nova senha com o código do e-mail: derruba as sessões abertas, destrava e abre uma nova. Código ruim/vencido: 400 `{reason: "invalid_reset_code"}`.
+   *
+   * @param {SmoothAgentDashboard.DashboardAuthResetRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthReset({
+   *         email: "email",
+   *         code: "code",
+   *         newPassword: "newPassword"
+   *     })
+   */
+  dashboardAuthReset(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthReset(request, requestOptions));
+  }
+  async __dashboardAuthReset(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _headers = mergeHeaders(
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/reset"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/auth/reset");
+  }
+  /**
+   * Conta nova + o dono dela + a primeira sessão. Senha ≥ 10 caracteres.
+   *
+   * @param {SmoothAgentDashboard.DashboardAuthSignupRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthSignup({
+   *         email: "email",
+   *         password: "password"
+   *     })
+   */
+  dashboardAuthSignup(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthSignup(request, requestOptions));
+  }
+  async __dashboardAuthSignup(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _headers = mergeHeaders(
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/signup"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/auth/signup");
+  }
+  /**
+   * Troca de conta SEM novo login: sessão nova na outra conta (não-membro = 404); a sessão atual é REVOGADA.
+   *
+   * @param {SmoothAgentDashboard.DashboardAuthSwitchAccountRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.dashboardAuthSwitchAccount({
+   *         accountId: "accountId"
+   *     })
+   */
+  dashboardAuthSwitchAccount(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__dashboardAuthSwitchAccount(request, requestOptions));
+  }
+  async __dashboardAuthSwitchAccount(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/auth/switch"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/auth/switch");
+  }
+  /**
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.invitesList()
+   */
+  invitesList(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__invitesList(requestOptions));
+  }
+  async __invitesList(requestOptions) {
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/invites"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v3/invites");
+  }
+  /**
+   * owner/admin (admin não convida owner; já membro = 409 `already_member`). Sem provedor de e-mail: a resposta traz o
+   * `token` e o `url` (`<studio>/invite#<token>`) — a ÚNICA vez; o owner manda o link. Convite pendente do mesmo e-mail é substituído.
+   *
+   * @param {SmoothAgentDashboard.InvitesCreateRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.invitesCreate({
+   *         email: "email"
+   *     })
+   */
+  invitesCreate(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__invitesCreate(request, requestOptions));
+  }
+  async __invitesCreate(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/invites"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/invites");
+  }
+  /**
+   * @param {SmoothAgentDashboard.InvitesRevokeRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.invitesRevoke({
+   *         id: "id"
+   *     })
+   */
+  invitesRevoke(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__invitesRevoke(request, requestOptions));
+  }
+  async __invitesRevoke(request, requestOptions) {
+    const { id } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        `v3/invites/${url_exports.encodePathParam(id, SmoothAgentDashboardError)}`
+      ),
+      method: "DELETE",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v3/invites/{id}");
+  }
+  /**
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.membersList()
+   */
+  membersList(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__membersList(requestOptions));
+  }
+  async __membersList(requestOptions) {
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/members"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v3/members");
+  }
+  /**
+   * Sair da organização da sessão (o último owner não sai: 409 `last_owner`). A sessão cai.
+   *
+   * @param {SmoothAgentDashboard.MembersLeaveRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.membersLeave()
+   */
+  membersLeave(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__membersLeave(request, requestOptions));
+  }
+  async __membersLeave(request = {}, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        "v3/members/me/leave"
+      ),
+      method: "POST",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v3/members/me/leave");
+  }
+  /**
+   * owner/admin (admin não remove owner; o último owner fica: 409 `last_owner`). O próprio id = sair.
+   *
+   * @param {SmoothAgentDashboard.MembersRemoveRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.membersRemove({
+   *         memberId: "memberId"
+   *     })
+   */
+  membersRemove(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__membersRemove(request, requestOptions));
+  }
+  async __membersRemove(request, requestOptions) {
+    const { memberId } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        `v3/members/${url_exports.encodePathParam(memberId, SmoothAgentDashboardError)}`
+      ),
+      method: "DELETE",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v3/members/{memberId}");
+  }
+  /**
+   * owner: qualquer papel (o último owner não é rebaixado: 409 `last_owner`); admin: só member↔admin de quem não é owner.
+   *
+   * @param {SmoothAgentDashboard.MembersUpdateRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.membersUpdate({
+   *         memberId: "memberId",
+   *         role: "owner"
+   *     })
+   */
+  membersUpdate(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__membersUpdate(request, requestOptions));
+  }
+  async __membersUpdate(request, requestOptions) {
+    const { memberId, ..._body } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+        `v3/members/${url_exports.encodePathParam(memberId, SmoothAgentDashboardError)}`
+      ),
+      method: "PATCH",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 401:
+          throw new UnauthorizedError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 403:
+          throw new ForbiddenError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 404:
+          throw new NotFoundError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 429:
+          throw new TooManyRequestsError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new SmoothAgentDashboardError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "PATCH", "/v3/members/{memberId}");
+  }
+  /**
+   * @param {SmoothAgentDashboard.PlatformAgentsRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.platformAgents()
+   */
+  async platformAgents(request = {}, requestOptions) {
+    const list = HttpResponsePromise.interceptFunction(
+      async (request2) => {
+        const { accountId, workspaceId, limit, cursor } = request2;
+        const _queryParams = {
+          accountId,
+          workspaceId,
+          limit,
+          cursor
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = mergeHeaders(
+          _authRequest.headers,
+          this._options?.headers,
+          requestOptions?.headers
+        );
+        const _response = await fetcher({
+          url: url_exports.join(
+            await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+            "v3/platform/agents"
+          ),
+          method: "GET",
+          headers: _headers,
+          queryString: url_exports.queryBuilder().addMany(_queryParams).add("accountId", _queryParams.accountId, { style: "comma" }).add("workspaceId", _queryParams.workspaceId, { style: "comma" }).add("limit", _queryParams.limit, { style: "comma" }).add("cursor", _queryParams.cursor, { style: "comma" }).mergeAdditional(requestOptions?.queryParams).build(),
+          timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+          maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+          abortSignal: requestOptions?.abortSignal,
+          fetchFn: this._options?.fetch,
+          logging: this._options.logging
+        });
+        if (_response.ok) {
+          return {
+            data: _response.body,
+            rawResponse: _response.rawResponse
+          };
+        }
+        if (_response.error.reason === "status-code") {
+          switch (_response.error.statusCode) {
+            case 400:
+              throw new BadRequestError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 401:
+              throw new UnauthorizedError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 403:
+              throw new ForbiddenError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 404:
+              throw new NotFoundError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 409:
+              throw new ConflictError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 429:
+              throw new TooManyRequestsError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 500:
+              throw new InternalServerError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            default:
+              throw new SmoothAgentDashboardError({
+                statusCode: _response.error.statusCode,
+                body: _response.error.body,
+                rawResponse: _response.rawResponse
+              });
+          }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v3/platform/agents");
+      }
+    );
+    const dataWithRawResponse = await list(request).withRawResponse();
+    return new Page({
+      response: dataWithRawResponse.data,
+      rawResponse: dataWithRawResponse.rawResponse,
+      hasNextPage: (response) => response?.nextCursor != null && !(typeof response?.nextCursor === "string" && response?.nextCursor === ""),
+      getItems: (response) => response?.data ?? [],
+      loadPage: (response) => {
+        return list(setObjectProperty(request, "cursor", response?.nextCursor));
+      }
+    });
+  }
+  /**
+   * @param {SmoothAgentDashboard.PlatformChatsRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.platformChats()
+   */
+  async platformChats(request = {}, requestOptions) {
+    const list = HttpResponsePromise.interceptFunction(
+      async (request2) => {
+        const { accountId, workspaceId, agentId, state, limit, cursor } = request2;
+        const _queryParams = {
+          accountId,
+          workspaceId,
+          agentId,
+          state,
+          limit,
+          cursor
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = mergeHeaders(
+          _authRequest.headers,
+          this._options?.headers,
+          requestOptions?.headers
+        );
+        const _response = await fetcher({
+          url: url_exports.join(
+            await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+            "v3/platform/chats"
+          ),
+          method: "GET",
+          headers: _headers,
+          queryString: url_exports.queryBuilder().addMany(_queryParams).add("accountId", _queryParams.accountId, { style: "comma" }).add("workspaceId", _queryParams.workspaceId, { style: "comma" }).add("agentId", _queryParams.agentId, { style: "comma" }).add("state", _queryParams.state, { style: "comma" }).add("limit", _queryParams.limit, { style: "comma" }).add("cursor", _queryParams.cursor, { style: "comma" }).mergeAdditional(requestOptions?.queryParams).build(),
+          timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+          maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+          abortSignal: requestOptions?.abortSignal,
+          fetchFn: this._options?.fetch,
+          logging: this._options.logging
+        });
+        if (_response.ok) {
+          return {
+            data: _response.body,
+            rawResponse: _response.rawResponse
+          };
+        }
+        if (_response.error.reason === "status-code") {
+          switch (_response.error.statusCode) {
+            case 400:
+              throw new BadRequestError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 401:
+              throw new UnauthorizedError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 403:
+              throw new ForbiddenError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 404:
+              throw new NotFoundError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 409:
+              throw new ConflictError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 429:
+              throw new TooManyRequestsError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 500:
+              throw new InternalServerError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            default:
+              throw new SmoothAgentDashboardError({
+                statusCode: _response.error.statusCode,
+                body: _response.error.body,
+                rawResponse: _response.rawResponse
+              });
+          }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v3/platform/chats");
+      }
+    );
+    const dataWithRawResponse = await list(request).withRawResponse();
+    return new Page({
+      response: dataWithRawResponse.data,
+      rawResponse: dataWithRawResponse.rawResponse,
+      hasNextPage: (response) => response?.nextCursor != null && !(typeof response?.nextCursor === "string" && response?.nextCursor === ""),
+      getItems: (response) => response?.data ?? [],
+      loadPage: (response) => {
+        return list(setObjectProperty(request, "cursor", response?.nextCursor));
+      }
+    });
+  }
+  /**
+   * @param {SmoothAgentDashboard.PlatformRunsRequest} request
+   * @param {SmoothAgentDashboardClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link SmoothAgentDashboard.BadRequestError}
+   * @throws {@link SmoothAgentDashboard.UnauthorizedError}
+   * @throws {@link SmoothAgentDashboard.ForbiddenError}
+   * @throws {@link SmoothAgentDashboard.NotFoundError}
+   * @throws {@link SmoothAgentDashboard.ConflictError}
+   * @throws {@link SmoothAgentDashboard.TooManyRequestsError}
+   * @throws {@link SmoothAgentDashboard.InternalServerError}
+   * @throws {@link errors.SmoothAgentDashboardError}
+   * @throws {@link errors.SmoothAgentDashboardTimeoutError}
+   *
+   * @example
+   *     await client.platformRuns()
+   */
+  async platformRuns(request = {}, requestOptions) {
+    const list = HttpResponsePromise.interceptFunction(
+      async (request2) => {
+        const { accountId, workspaceId, agentId, chatId, status, limit, cursor } = request2;
+        const _queryParams = {
+          accountId,
+          workspaceId,
+          agentId,
+          chatId,
+          status,
+          limit,
+          cursor
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = mergeHeaders(
+          _authRequest.headers,
+          this._options?.headers,
+          requestOptions?.headers
+        );
+        const _response = await fetcher({
+          url: url_exports.join(
+            await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? SmoothAgentDashboardEnvironment.Default,
+            "v3/platform/runs"
+          ),
+          method: "GET",
+          headers: _headers,
+          queryString: url_exports.queryBuilder().addMany(_queryParams).add("accountId", _queryParams.accountId, { style: "comma" }).add("workspaceId", _queryParams.workspaceId, { style: "comma" }).add("agentId", _queryParams.agentId, { style: "comma" }).add("chatId", _queryParams.chatId, { style: "comma" }).add("status", _queryParams.status, { style: "comma" }).add("limit", _queryParams.limit, { style: "comma" }).add("cursor", _queryParams.cursor, { style: "comma" }).mergeAdditional(requestOptions?.queryParams).build(),
+          timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+          maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+          abortSignal: requestOptions?.abortSignal,
+          fetchFn: this._options?.fetch,
+          logging: this._options.logging
+        });
+        if (_response.ok) {
+          return {
+            data: _response.body,
+            rawResponse: _response.rawResponse
+          };
+        }
+        if (_response.error.reason === "status-code") {
+          switch (_response.error.statusCode) {
+            case 400:
+              throw new BadRequestError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 401:
+              throw new UnauthorizedError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 403:
+              throw new ForbiddenError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 404:
+              throw new NotFoundError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 409:
+              throw new ConflictError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 429:
+              throw new TooManyRequestsError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            case 500:
+              throw new InternalServerError(
+                _response.error.body,
+                _response.rawResponse
+              );
+            default:
+              throw new SmoothAgentDashboardError({
+                statusCode: _response.error.statusCode,
+                body: _response.error.body,
+                rawResponse: _response.rawResponse
+              });
+          }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v3/platform/runs");
+      }
+    );
+    const dataWithRawResponse = await list(request).withRawResponse();
+    return new Page({
+      response: dataWithRawResponse.data,
+      rawResponse: dataWithRawResponse.rawResponse,
+      hasNextPage: (response) => response?.nextCursor != null && !(typeof response?.nextCursor === "string" && response?.nextCursor === ""),
+      getItems: (response) => response?.data ?? [],
+      loadPage: (response) => {
+        return list(setObjectProperty(request, "cursor", response?.nextCursor));
+      }
+    });
+  }
+  /**
+   * Make a passthrough request using the SDK's configured auth, retry, logging, etc.
+   * This is useful for making requests to endpoints not yet supported in the SDK.
+   * The input can be a URL string, URL object, or Request object. Relative paths are resolved against the configured base URL.
+   *
+   * @param {Request | string | URL} input - The URL, path, or Request object.
+   * @param {RequestInit} init - Standard fetch RequestInit options.
+   * @param {core.PassthroughRequest.RequestOptions} requestOptions - Per-request overrides (timeout, retries, headers, abort signal).
+   * @returns {Promise<Response>} A standard Response object.
+   */
+  async fetch(input, init, requestOptions) {
+    return makePassthroughRequest(
+      input,
+      init,
+      {
+        baseUrl: this._options.baseUrl ?? this._options.environment,
+        headers: this._options.headers,
+        timeoutInSeconds: this._options.timeoutInSeconds,
+        maxRetries: this._options.maxRetries,
+        fetch: this._options.fetch,
+        logging: this._options.logging,
+        getAuthHeaders: async () => (await this._options.authProvider.getAuthRequest()).headers
+      },
+      requestOptions
+    );
+  }
+};
+
+// ../../generated/ts-dashboard/core/logging/exports.ts
+var logging;
+((logging2) => {
+  logging2.LogLevel = LogLevel;
+  logging2.ConsoleLogger = ConsoleLogger;
+})(logging || (logging = {}));
+
+// src/dashboard.ts
+var SmoothAgentDashboardAuth = class {
+  /** O cliente gerado, inteiro. */
+  api;
+  constructor(o = {}) {
+    const key = o.token;
+    this.api = new SmoothAgentDashboardClient({
+      baseUrl: (o.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "").replace(/\/v3$/, ""),
+      ...key === void 0 ? { auth: false, token: "" } : { token: typeof key === "string" ? key : async () => key() },
+      ...o.fetch ? { fetch: o.fetch } : {},
+      headers: idempotencyHeaders()
+    });
+  }
+  login = (...a) => this.api.dashboardAuthLogin(...a);
+  logout = (...a) => this.api.dashboardAuthLogout(...a);
+  me = (...a) => this.api.dashboardAuthMe(...a);
+  signup = (...a) => this.api.dashboardAuthSignup(...a);
+  forgot = (...a) => this.api.dashboardAuthForgot(...a);
+  reset = (...a) => this.api.dashboardAuthReset(...a);
+  changePassword = (...a) => this.api.dashboardAuthChangePassword(...a);
+};
+export {
+  api_exports as SmoothAgentDashboard,
+  SmoothAgentDashboardAuth,
+  SmoothAgentDashboardClient,
+  SmoothAgentDashboardError,
+  SmoothAgentDashboardTimeoutError
+};
+//# sourceMappingURL=dashboard.js.map