@flurin17/rapidata-typescript-sdk 0.1.0

package/dist/generated/index.cjs

@@ -0,0 +1,4465 @@
+'use strict';
+
+// src/generated/core/ApiError.ts
+var ApiError = class extends Error {
+  url;
+  status;
+  statusText;
+  body;
+  request;
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// src/generated/core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var CancelablePromise = class {
+  #isResolved;
+  #isRejected;
+  #isCancelled;
+  #cancelHandlers;
+  #promise;
+  #resolve;
+  #reject;
+  constructor(executor) {
+    this.#isResolved = false;
+    this.#isRejected = false;
+    this.#isCancelled = false;
+    this.#cancelHandlers = [];
+    this.#promise = new Promise((resolve2, reject) => {
+      this.#resolve = resolve2;
+      this.#reject = reject;
+      const onResolve = (value) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isResolved = true;
+        if (this.#resolve) this.#resolve(value);
+      };
+      const onReject = (reason) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isRejected = true;
+        if (this.#reject) this.#reject(reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#cancelHandlers.push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => this.#isResolved
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => this.#isRejected
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => this.#isCancelled
+      });
+      return executor(onResolve, onReject, onCancel);
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return this.#promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this.#promise.catch(onRejected);
+  }
+  finally(onFinally) {
+    return this.#promise.finally(onFinally);
+  }
+  cancel() {
+    if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+      return;
+    }
+    this.#isCancelled = true;
+    if (this.#cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this.#cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    this.#cancelHandlers.length = 0;
+    if (this.#reject) this.#reject(new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this.#isCancelled;
+  }
+};
+
+// src/generated/core/OpenAPI.ts
+var OpenAPI = {
+  BASE: "https://api.rabbitdata.ch",
+  VERSION: "1",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0
+};
+
+// src/generated/core/request.ts
+var isDefined = (value) => {
+  return value !== void 0 && value !== null;
+};
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var isBlob = (value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+};
+var isFormData = (value) => {
+  return value instanceof FormData;
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process = (key, value) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
+  }
+  return "";
+};
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = `${config.BASE}${path}`;
+  if (options.query) {
+    return `${url}${getQueryString(options.query)}`;
+  }
+  return url;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process(key, v));
+      } else {
+        process(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+var resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+var getHeaders = async (config, options) => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    resolve(options, config.TOKEN),
+    resolve(options, config.USERNAME),
+    resolve(options, config.PASSWORD),
+    resolve(options, config.HEADERS)
+  ]);
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([_, value]) => isDefined(value)).reduce((headers2, [key, value]) => ({
+    ...headers2,
+    [key]: String(value)
+  }), {});
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body !== void 0) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return new Headers(headers);
+};
+var getRequestBody = (options) => {
+  if (options.body !== void 0) {
+    if (options.mediaType?.includes("/json")) {
+      return JSON.stringify(options.body);
+    } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
+    }
+  }
+  return void 0;
+};
+var sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
+  const controller = new AbortController();
+  const request2 = {
+    headers,
+    body: body ?? formData,
+    method: options.method,
+    signal: controller.signal
+  };
+  if (config.WITH_CREDENTIALS) {
+    request2.credentials = config.CREDENTIALS;
+  }
+  onCancel(() => controller.abort());
+  return await fetch(url, request2);
+};
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = async (response) => {
+  if (response.status !== 204) {
+    try {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType) {
+        const jsonTypes = ["application/json", "application/problem+json"];
+        const isJSON = jsonTypes.some((type) => contentType.toLowerCase().startsWith(type));
+        if (isJSON) {
+          return await response.json();
+        } else {
+          return await response.text();
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return void 0;
+};
+var catchErrorCodes = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    const errorStatus = result.status ?? "unknown";
+    const errorStatusText = result.statusText ?? "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return void 0;
+      }
+    })();
+    throw new ApiError(
+      options,
+      result,
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+    );
+  }
+};
+var request = (config, options) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options);
+      if (!onCancel.isCancelled) {
+        const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+        const responseBody = await getResponseBody(response);
+        const responseHeader = getResponseHeader(response, options.responseHeader);
+        const result = {
+          url,
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody
+        };
+        catchErrorCodes(options, result);
+        resolve2(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+// src/generated/services/AssetService.ts
+var AssetService = class {
+  /**
+   * Compresses an uploaded image and returns the WebP result.
+   * Compression metrics are returned in response headers: X-Original-Size, X-Compressed-Size,
+   * X-Processing-Time-Ms, X-Original-Dimensions, X-Output-Dimensions.
+   * @returns binary OK
+   * @throws ApiError
+   */
+  static postAssetCompress({
+    formData,
+    library,
+    quality = 85,
+    maxdim = 800
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/asset/compress",
+      query: {
+        "library": library,
+        "quality": quality,
+        "maxdim": maxdim
+      },
+      formData,
+      mediaType: "multipart/form-data",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Uploads a single asset to S3 and returns the asset details.
+   * This endpoint allows uploading a single file to S3 storage with the asset creator.
+   * The uploaded asset will be stored using the configured S3 settings and a unique filename will be generated.
+   * @returns UploadFileResult OK
+   * @throws ApiError
+   */
+  static postAssetFile({
+    formData
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/asset/file",
+      formData,
+      mediaType: "multipart/form-data"
+    });
+  }
+  /**
+   * Uploads a single asset to S3 and returns the asset details.
+   * This endpoint allows uploading a single file to S3 storage with the asset creator.
+   * The uploaded asset will be stored using the configured S3 settings and a unique filename will be generated.
+   * @returns UploadFileResult OK
+   * @throws ApiError
+   */
+  static postAssetUrl({
+    url
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/asset/url",
+      query: {
+        "url": url
+      }
+    });
+  }
+  /**
+   * Gets the metadata for an asset by file name.
+   * This endpoint retrieves metadata information for an asset stored in S3.
+   * The metadata includes details such as content type, size, creation date, and custom metadata fields.
+   * @returns GetFileMetadataResult OK
+   * @throws ApiError
+   */
+  static getAssetMetadata({
+    fileName
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/asset/{fileName}/metadata",
+      path: {
+        "fileName": fileName
+      },
+      errors: {
+        404: `Not Found`
+      }
+    });
+  }
+};
+
+// src/generated/services/AudienceService.ts
+var AudienceService = class {
+  /**
+   * Deletes the specified audience.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteAudience({
+    audienceId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/audience/{audienceId}",
+      path: {
+        "audienceId": audienceId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Gets an audience by its Id.
+   * @returns GetAudienceByIdResult OK
+   * @throws ApiError
+   */
+  static getAudience({
+    audienceId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/audience/{audienceId}",
+      path: {
+        "audienceId": audienceId
+      }
+    });
+  }
+  /**
+   * Patches an existing audience.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchAudience({
+    audienceId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/audience/{audienceId}",
+      path: {
+        "audienceId": audienceId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Gets the count of users in each state for the specified audience.
+   * @returns GetAudienceUserStateMetricsResult OK
+   * @throws ApiError
+   */
+  static getAudienceUserMetrics({
+    audienceId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/audience/{audienceId}/user-metrics",
+      path: {
+        "audienceId": audienceId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Pauses the distillation campaign for the specified audience.
+   * @returns void
+   * @throws ApiError
+   */
+  static postAudiencePauseDistillation({
+    audienceId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/audience/{audienceId}/pause-distillation",
+      path: {
+        "audienceId": audienceId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Queries jobs for the specified audience.
+   * @returns PagedResultOfQueryJobsResult OK
+   * @throws ApiError
+   */
+  static getAudienceJobs({
+    audienceId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/audience/{audienceId}/jobs",
+      path: {
+        "audienceId": audienceId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Rebuilds the distilling campaign for the specified audience.
+   * Recalculates campaign filters and selections based on the audience's current settings
+   * (demographic filters, exit conditions, etc.).
+   * @returns void
+   * @throws ApiError
+   */
+  static postAudienceRebuildDistillingCampaign({
+    audienceId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/audience/{audienceId}/rebuild-distilling-campaign",
+      path: {
+        "audienceId": audienceId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Recreates external audiences for the specified audience.
+   * @returns void
+   * @throws ApiError
+   */
+  static postAudienceRecreateExternalAudiences({
+    audienceId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/audience/{audienceId}/recreate-external-audiences",
+      path: {
+        "audienceId": audienceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Resumes the distillation campaign for the specified audience.
+   * @returns void
+   * @throws ApiError
+   */
+  static postAudienceResumeDistillation({
+    audienceId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/audience/{audienceId}/resume-distillation",
+      path: {
+        "audienceId": audienceId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Starts recruiting users for the specified audience.
+   * @returns void
+   * @throws ApiError
+   */
+  static postAudienceRecruit({
+    audienceId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/audience/{audienceId}/recruit",
+      path: {
+        "audienceId": audienceId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Updates the boost configuration for the specified audience.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchAudienceBoostConfig({
+    audienceId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/audience/{audienceId}/boost-config",
+      path: {
+        "audienceId": audienceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Queries all available audiences.
+   * @returns PagedResultOfQueryAudiencesResult OK
+   * @throws ApiError
+   */
+  static getAudiences({
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/audiences",
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Creates a new empty audience.
+   * An audience is a group of users that are trained to solve particular tasks.
+   * @returns CreateAudienceResult OK
+   * @throws ApiError
+   */
+  static postAudience({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/audience",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+};
+
+// src/generated/services/BatchUploadService.ts
+var BatchUploadService = class {
+  /**
+   * Aborts the specified batch upload.
+   * URLs already processed will not be reverted. Only remaining URLs are prevented from processing.
+   * @returns void
+   * @throws ApiError
+   */
+  static postAssetBatchUploadAbort({
+    batchUploadId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/asset/batch-upload/{batchUploadId}/abort",
+      path: {
+        "batchUploadId": batchUploadId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Creates a batch upload and queues processing for each URL.
+   * Each URL is processed asynchronously. Use the batch upload status or result endpoints to track progress.
+   * @returns CreateBatchUploadEndpoint_Output OK
+   * @throws ApiError
+   */
+  static postAssetBatchUpload({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/asset/batch-upload",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Gets the full result of a batch upload including all items.
+   * @returns GetBatchUploadResultEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getAssetBatchUpload({
+    batchUploadId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/asset/batch-upload/{batchUploadId}",
+      path: {
+        "batchUploadId": batchUploadId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Gets aggregated status for batch uploads identified by IDs or a correlation ID.
+   * @returns GetBatchUploadStatusEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getAssetBatchUploadStatus({
+    batchUploadIds,
+    correlationId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/asset/batch-upload/status",
+      query: {
+        "batchUploadIds": batchUploadIds,
+        "correlationId": correlationId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/BenchmarkService.ts
+var BenchmarkService = class {
+  /**
+   * Returns the pairwise vote matrix for a benchmark.
+   * The matrix is returned in pandas split format.
+   * @returns VoteMatrixResult OK
+   * @throws ApiError
+   */
+  static getBenchmarkMatrix({
+    benchmarkId,
+    tags,
+    participantIds,
+    leaderboardIds,
+    useWeightedScoring = false
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark/{benchmarkId}/matrix",
+      path: {
+        "benchmarkId": benchmarkId
+      },
+      query: {
+        "tags": tags,
+        "participantIds": participantIds,
+        "leaderboardIds": leaderboardIds,
+        "useWeightedScoring": useWeightedScoring
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Returns the combined pairwise vote matrix for multiple benchmarks.
+   * @returns GetCombinedBenchmarkMatrixEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getBenchmarkCombinedMatrix({
+    benchmarkIds,
+    useWeightedScoring = false
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark/combined-matrix",
+      query: {
+        "benchmarkIds": benchmarkIds,
+        "useWeightedScoring": useWeightedScoring
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Returns the combined standings for multiple benchmarks.
+   * @returns GetCombinedBenchmarkStandingsEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getBenchmarkCombinedStandings({
+    benchmarkIds,
+    useWeightedScoring = false,
+    includeConfidenceIntervals = false
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark/combined-standings",
+      query: {
+        "benchmarkIds": benchmarkIds,
+        "useWeightedScoring": useWeightedScoring,
+        "includeConfidenceIntervals": includeConfidenceIntervals
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Queries all benchmarks of the user.
+   * @returns PagedResultOfBenchmarkQueryResult OK
+   * @throws ApiError
+   */
+  static getBenchmarks({
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmarks",
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Queries all leaderboards for the current user's benchmarks.
+   * @returns PagedResultOfLeaderboardsQueryResult OK
+   * @throws ApiError
+   */
+  static getBenchmarkLeaderboards({
+    benchmarkId,
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark/{benchmarkId}/leaderboards",
+      path: {
+        "benchmarkId": benchmarkId
+      },
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Creates a benchmark
+   * @returns CreateBenchmarkResult OK
+   * @throws ApiError
+   */
+  static postBenchmark({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/benchmark",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Returns a single benchmark by its ID.
+   * @returns GetBenchmarkByIdResult OK
+   * @throws ApiError
+   */
+  static getBenchmark({
+    benchmarkId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark/{benchmarkId}",
+      path: {
+        "benchmarkId": benchmarkId
+      }
+    });
+  }
+  /**
+   * Deletes a single benchmark.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteBenchmark({
+    benchmarkId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/benchmark/{benchmarkId}",
+      path: {
+        "benchmarkId": benchmarkId
+      }
+    });
+  }
+  /**
+   * Updates a benchmark using patch semantics.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchBenchmark({
+    benchmarkId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/benchmark/{benchmarkId}",
+      path: {
+        "benchmarkId": benchmarkId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Query all participants within a benchmark
+   * @returns PagedResultOfParticipantByBenchmark OK
+   * @throws ApiError
+   */
+  static getBenchmarkParticipants({
+    benchmarkId,
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark/{benchmarkId}/participants",
+      path: {
+        "benchmarkId": benchmarkId
+      },
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Creates a participant in a benchmark.
+   * @returns CreateBenchmarkParticipantResult OK
+   * @throws ApiError
+   */
+  static postBenchmarkParticipants({
+    benchmarkId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/benchmark/{benchmarkId}/participants",
+      path: {
+        "benchmarkId": benchmarkId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Queries all the standings for a benchmark by its ID.
+   * @returns StandingsByBenchmarkResult OK
+   * @throws ApiError
+   */
+  static getBenchmarkStandings({
+    benchmarkId,
+    tags,
+    participantIds,
+    leaderboardIds,
+    useWeightedScoring = false,
+    includeConfidenceIntervals = false
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark/{benchmarkId}/standings",
+      path: {
+        "benchmarkId": benchmarkId
+      },
+      query: {
+        "tags": tags,
+        "participantIds": participantIds,
+        "leaderboardIds": leaderboardIds,
+        "useWeightedScoring": useWeightedScoring,
+        "includeConfidenceIntervals": includeConfidenceIntervals
+      }
+    });
+  }
+  /**
+   * Creates a copy of a public benchmark and all of its related entities
+   * @returns ForkBenchmarkResult OK
+   * @throws ApiError
+   */
+  static postBenchmarkFork({
+    benchmarkId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/benchmark/{benchmarkId}/fork",
+      path: {
+        "benchmarkId": benchmarkId
+      }
+    });
+  }
+  /**
+   * Returns the paged prompts of a benchmark by its ID.
+   * @returns PagedResultOfPromptByBenchmarkResult OK
+   * @throws ApiError
+   */
+  static getBenchmarkPrompts({
+    benchmarkId,
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark/{benchmarkId}/prompts",
+      path: {
+        "benchmarkId": benchmarkId
+      },
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Returns the paged prompts of a benchmark by its ID.
+   * @returns PagedResultOfSampleByIdentifier OK
+   * @throws ApiError
+   */
+  static getBenchmarkSamples({
+    benchmarkId,
+    identifier,
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark/{benchmarkId}/samples/{identifier}",
+      path: {
+        "benchmarkId": benchmarkId,
+        "identifier": identifier
+      },
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Adds a new prompt to a benchmark.
+   * @returns CreateBenchmarkPromptResult OK
+   * @throws ApiError
+   */
+  static postBenchmarkPrompt({
+    benchmarkId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/benchmark/{benchmarkId}/prompt",
+      path: {
+        "benchmarkId": benchmarkId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Query all tags within a benchmark
+   * @returns TagsByBenchmarkResult OK
+   * @throws ApiError
+   */
+  static getBenchmarkTags({
+    benchmarkId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark/{benchmarkId}/tags",
+      path: {
+        "benchmarkId": benchmarkId
+      }
+    });
+  }
+};
+
+// src/generated/services/CacheService.ts
+var CacheService = class {
+  /**
+   * Returns the current state of the in-memory campaign cache.
+   * @returns GetCampaignCacheEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getCampaignCacheCampaigns() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/campaign/cache/campaigns",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Returns the current state of the in-memory default user score cache.
+   * @returns GetUserScoreCacheEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getCampaignCacheUserScores() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/campaign/cache/user-scores",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/CampaignService.ts
+var CampaignService = class {
+  /**
+   * Changes the boost configuration.
+   * @returns void
+   * @throws ApiError
+   */
+  static putCampaignBoost({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/campaign/boost",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Returns the current boost status including active and inactive campaigns.
+   * @returns GetBoostStatusEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getCampaignBoostStatus() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/campaign/boost/status",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * @returns any OK
+   * @throws ApiError
+   */
+  static getCampaignMonitor() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/campaign/monitor",
+      errors: {
+        400: `Bad Request`
+      }
+    });
+  }
+  /**
+   * Pauses the specified campaign.
+   * @returns void
+   * @throws ApiError
+   */
+  static postCampaignPause({
+    campaignId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/campaign/{campaignId}/pause",
+      path: {
+        "campaignId": campaignId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Queries campaigns with optional filtering, sorting, and pagination.
+   * @returns QueryCampaignsEndpoint_PagedResultOfOutput OK
+   * @throws ApiError
+   */
+  static getCampaigns({
+    page,
+    pageSize,
+    sort,
+    id,
+    name,
+    status,
+    priority,
+    ownerMail,
+    createdAt
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/campaigns",
+      query: {
+        "page": page,
+        "page_size": pageSize,
+        "sort": sort,
+        "id": id,
+        "name": name,
+        "status": status,
+        "priority": priority,
+        "owner_mail": ownerMail,
+        "created_at": createdAt
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Resumes the specified campaign.
+   * @returns void
+   * @throws ApiError
+   */
+  static postCampaignResume({
+    campaignId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/campaign/{campaignId}/resume",
+      path: {
+        "campaignId": campaignId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Updates the specified campaign's properties.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchCampaign({
+    campaignId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/campaign/{campaignId}",
+      path: {
+        "campaignId": campaignId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/ClientService.ts
+var ClientService = class {
+  /**
+   * Queries the clients for the current customer.
+   * A client allows a customer to authenticate with the APIs without using their own credentials.
+   * This is useful for creating service accounts or other automated processes,
+   * as when using the Rapidata Python SDK.
+   * @returns PagedResultOfClientsQueryResult OK
+   * @throws ApiError
+   */
+  static getClients({
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/clients",
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Gets a specific client by its ID.
+   * @returns ClientModel OK
+   * @throws ApiError
+   */
+  static getClient({
+    clientId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/client/{clientId}",
+      path: {
+        "clientId": clientId
+      }
+    });
+  }
+  /**
+   * Deletes a customers' client.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteClient({
+    clientId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/client/{clientId}",
+      path: {
+        "clientId": clientId
+      }
+    });
+  }
+  /**
+   * Creates a new client for the current customer.
+   * @returns CreateCustomerClientResult OK
+   * @throws ApiError
+   */
+  static postClient({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/client",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Registers a new client dynamically.
+   * The implementation of this method follows the OpenID Connect Dynamic Client Registration.
+   * @returns ClientModel Created
+   * @throws ApiError
+   */
+  static postClientRegister({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/client/register",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+};
+
+// src/generated/services/CustomerService.ts
+var CustomerService = class {
+  /**
+   * Queries customers with filtering and pagination.
+   * Results are scoped to customers that belong to the caller's organization.
+   * @returns QueryCustomersEndpoint_PagedResultOfOutput OK
+   * @throws ApiError
+   */
+  static getCustomers({
+    page,
+    pageSize,
+    sort,
+    id,
+    email,
+    organizationName,
+    organizationId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/customers",
+      query: {
+        "page": page,
+        "page_size": pageSize,
+        "sort": sort,
+        "id": id,
+        "email": email,
+        "organization_name": organizationName,
+        "organization_id": organizationId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/CustomerRapidService.ts
+var CustomerRapidService = class {
+  /**
+   * Allows querying all rapids that have been flagged.
+   * @returns PagedResultOfRapidModel OK
+   * @throws ApiError
+   */
+  static getRapidsFlagged({
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/rapids/flagged",
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Gets all responses for a given rapid.
+   * @returns GetResponsesForRapidResult OK
+   * @throws ApiError
+   */
+  static getRapidResponses({
+    rapidId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/rapid/{rapidId}/responses",
+      path: {
+        "rapidId": rapidId
+      }
+    });
+  }
+  /**
+   * A public endpoint to query the most recent responses globally
+   * @returns GetPublicResponsesResult OK
+   * @throws ApiError
+   */
+  static getRapidGlobalResponses() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/rapid/global-responses"
+    });
+  }
+  /**
+   * Creates a new Demographic Rapid with JSON body.
+   * @returns CreateRapidResult OK
+   * @throws ApiError
+   */
+  static postRapidDemographic({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/rapid/demographic",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Updates the validation information of a Rapid.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchRapidValidation({
+    rapidId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/rapid/validation/{rapidId}",
+      path: {
+        "rapidId": rapidId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Unflags a flagged rapid.
+   * This will add the rapid back to the active labeling pool and prevent it from being flagged again.
+   * @returns void
+   * @throws ApiError
+   */
+  static postRapidUnflag({
+    rapidId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/rapid/{rapidId}/unflag",
+      path: {
+        "rapidId": rapidId
+      }
+    });
+  }
+  /**
+   * Deletes a rapid.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteRapid({
+    rapidId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/rapid/{rapidId}",
+      path: {
+        "rapidId": rapidId
+      }
+    });
+  }
+  /**
+   * Queries rapids that are potentially eligible for validation set creation.
+   * @returns PagedResultOfQueryValidationRapidEligibilityResult OK
+   * @throws ApiError
+   */
+  static getRapidValidationPotential({
+    correlationId,
+    minResponses,
+    minConfidence,
+    targetGroupId,
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/rapid/{correlationId}/validation-potential",
+      path: {
+        "correlationId": correlationId
+      },
+      query: {
+        "MinResponses": minResponses,
+        "MinConfidence": minConfidence,
+        "TargetGroupId": targetGroupId,
+        "request": request2
+      }
+    });
+  }
+};
+
+// src/generated/services/DatapointService.ts
+var DatapointService = class {
+  /**
+   * Gets a datapoint by its id.
+   * @returns GetDatapointByIdResult OK
+   * @throws ApiError
+   */
+  static getDatapoint({
+    datapointId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/datapoint/{datapointId}",
+      path: {
+        "datapointId": datapointId
+      }
+    });
+  }
+  /**
+   * Deletes a datapoint by its id.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteDatapoint({
+    datapointId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/datapoint/{datapointId}",
+      path: {
+        "datapointId": datapointId
+      }
+    });
+  }
+};
+
+// src/generated/services/DatasetService.ts
+var DatasetService = class {
+  /**
+   * Creates a new empty dataset.
+   * @returns CreateDatasetEndpoint_Output OK
+   * @throws ApiError
+   */
+  static postDataset({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/dataset",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Gets a dataset by its id.
+   * @returns GetDatasetByIdResult OK
+   * @throws ApiError
+   */
+  static getDataset({
+    datasetId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/dataset/{datasetId}",
+      path: {
+        "datasetId": datasetId
+      }
+    });
+  }
+  /**
+   * Gets all datapoints of a dataset.
+   * @returns PagedResultOfQueryDatapointsByDatasetIdResult OK
+   * @throws ApiError
+   */
+  static getDatasetDatapoints({
+    datasetId,
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/dataset/{datasetId}/datapoints",
+      path: {
+        "datasetId": datasetId
+      },
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Gets the upload progress of a dataset.
+   * @returns GetDatasetProgressResult OK
+   * @throws ApiError
+   */
+  static getDatasetProgress({
+    datasetId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/dataset/{datasetId}/progress",
+      path: {
+        "datasetId": datasetId
+      }
+    });
+  }
+  /**
+   * Gets a list of all datapoints that failed to upload.
+   * A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL
+   * and the URL is not accessible.
+   * @returns GetFailedDatapointsResult OK
+   * @throws ApiError
+   */
+  static getDatasetDatapointsFailed({
+    datasetId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/dataset/{datasetId}/datapoints/failed",
+      path: {
+        "datasetId": datasetId
+      }
+    });
+  }
+  /**
+   * Creates a datapoint with JSON body.
+   * @returns CreateDatapointResult OK
+   * @throws ApiError
+   */
+  static postDatasetDatapoint({
+    datasetId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/dataset/{datasetId}/datapoint",
+      path: {
+        "datasetId": datasetId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Updates the name of a dataset.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchDatasetName({
+    datasetId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/dataset/{datasetId}/name",
+      path: {
+        "datasetId": datasetId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+};
+
+// src/generated/services/DatasetGroupService.ts
+var DatasetGroupService = class {
+  /**
+   * Creates a new dataset group.
+   * @returns void
+   * @throws ApiError
+   */
+  static postDatasetGroup({
+    datasetId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/dataset/{datasetId}/group",
+      path: {
+        "datasetId": datasetId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/EvaluationWorkflowService.ts
+var EvaluationWorkflowService = class {
+  /**
+   * Get the results for an evaluation workflow.
+   * @returns PagedResultOfGetWorkflowResultsResult OK
+   * @throws ApiError
+   */
+  static getWorkflowEvaluationResults({
+    workflowId,
+    model
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workflow/evaluation/{workflowId}/results",
+      path: {
+        "workflowId": workflowId
+      },
+      query: {
+        "model": model
+      }
+    });
+  }
+};
+
+// src/generated/services/ExamplesService.ts
+var ExamplesService = class {
+  /**
+   * Adds a new example to an audience.
+   * @returns void
+   * @throws ApiError
+   */
+  static postAudienceExample({
+    audienceId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/audience/{audienceId}/example",
+      path: {
+        "audienceId": audienceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Deletes the specified audience example.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteAudienceExample({
+    exampleId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/audience/example/{exampleId}",
+      path: {
+        "exampleId": exampleId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Queries all examples for the specified audience.
+   * @returns QueryExamplesForAudienceEndpoint_PagedResultOfOutput OK
+   * @throws ApiError
+   */
+  static getAudienceExamples({
+    audienceId,
+    page,
+    pageSize
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/audience/{audienceId}/examples",
+      path: {
+        "audienceId": audienceId
+      },
+      query: {
+        "page": page,
+        "page_size": pageSize
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Updates an example's properties within an audience.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchAudienceExample({
+    audienceId,
+    exampleId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/audience/{audienceId}/example/{exampleId}",
+      path: {
+        "audienceId": audienceId,
+        "exampleId": exampleId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/FeedbackService.ts
+var FeedbackService = class {
+  /**
+   * Submits feedback about our services.
+   * @returns void
+   * @throws ApiError
+   */
+  static postFeedback({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/feedback",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+};
+
+// src/generated/services/FlowService.ts
+var FlowService = class {
+  /**
+   * Deletes a flow.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteFlow({
+    flowId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/flow/{flowId}",
+      path: {
+        "flowId": flowId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Retrieves a flow by its ID.
+   * @returns GetFlowByIdEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getFlow({
+    flowId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/flow/{flowId}",
+      path: {
+        "flowId": flowId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Returns the distribution of completion durations (in seconds) per completed flow item.
+   * @returns GetCompletionTimeHistogramEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getFlowRankingCompletionTimeHistogram({
+    flowId,
+    from,
+    to,
+    bucketCount
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/flow/ranking/{flowId}/completion-time-histogram",
+      path: {
+        "flowId": flowId
+      },
+      query: {
+        "from": from,
+        "to": to,
+        "bucketCount": bucketCount
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Returns flow item creation counts bucketed over time.
+   * @returns GetFlowItemCreationTimeseriesEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getFlowRankingFlowItemCreationTimeseries({
+    flowId,
+    from,
+    to,
+    datapoints
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/flow/ranking/{flowId}/flow-item-creation-timeseries",
+      path: {
+        "flowId": flowId
+      },
+      query: {
+        "from": from,
+        "to": to,
+        "datapoints": datapoints
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Returns the distribution of total votes per completed flow item.
+   * @returns GetResponseCountHistogramEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getFlowRankingResponseCountHistogram({
+    flowId,
+    from,
+    to,
+    bucketCount
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/flow/ranking/{flowId}/response-count-histogram",
+      path: {
+        "flowId": flowId
+      },
+      query: {
+        "from": from,
+        "to": to,
+        "bucketCount": bucketCount
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Returns average response counts bucketed over time for completed flow items.
+   * @returns GetResponseCountTimeseriesEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getFlowRankingResponseCountTimeseries({
+    flowId,
+    from,
+    to,
+    datapoints
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/flow/ranking/{flowId}/response-count-timeseries",
+      path: {
+        "flowId": flowId
+      },
+      query: {
+        "from": from,
+        "to": to,
+        "datapoints": datapoints
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Queries flows with filtering and pagination.
+   * @returns QueryFlowsEndpoint_PagedResultOfOutput OK
+   * @throws ApiError
+   */
+  static getFlow1({
+    page,
+    pageSize,
+    sort,
+    name,
+    createdAt
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/flow",
+      query: {
+        "page": page,
+        "page_size": pageSize,
+        "sort": sort,
+        "name": name,
+        "created_at": createdAt
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/FlowItemService.ts
+var FlowItemService = class {
+  /**
+   * Stops the specified flow item and triggers partial result processing.
+   * @returns void
+   * @throws ApiError
+   */
+  static postFlowItemStop({
+    flowItemId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/flow/item/{flowItemId}/stop",
+      path: {
+        "flowItemId": flowItemId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/GroupedRankingWorkflowService.ts
+var GroupedRankingWorkflowService = class {
+  /**
+   * Get the result overview for a multi ranking workflow.
+   * @returns PagedResultOfGetGroupedRankingWorkflowResultsResult OK
+   * @throws ApiError
+   */
+  static getWorkflowGroupedRankingResults({
+    workflowId,
+    model
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workflow/grouped-ranking/{workflowId}/results",
+      path: {
+        "workflowId": workflowId
+      },
+      query: {
+        "model": model
+      }
+    });
+  }
+};
+
+// src/generated/services/IdentityService.ts
+var IdentityService = class {
+  /**
+   * Creates a pair of read and write keys for a client.
+   * The write key is used to store the authentication result.
+   * The read key is used to retrieve the authentication result.
+   * @returns CreateBridgeTokenResult OK
+   * @throws ApiError
+   */
+  static postIdentityBridgeToken({
+    clientId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/identity/bridge-token",
+      query: {
+        "clientId": clientId
+      }
+    });
+  }
+  /**
+   * Tries to read the bridge token keys for a given read key.
+   * The read key is used to retrieve the authentication result written by the write key.
+   * @returns ReadBridgeTokenKeysResult OK
+   * @returns NotAvailableYetResult Accepted
+   * @throws ApiError
+   */
+  static getIdentityBridgeToken({
+    readKey
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/identity/bridge-token",
+      query: {
+        "readKey": readKey
+      }
+    });
+  }
+  /**
+   * Sets the referrer for the current customer.
+   * @returns void
+   * @throws ApiError
+   */
+  static postIdentityReferrer({
+    referrer
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/identity/referrer",
+      query: {
+        "referrer": referrer
+      }
+    });
+  }
+  /**
+   * Signs in a user using a token received from Google One Tap.
+   * @returns void
+   * @throws ApiError
+   */
+  static postIdentityGoogleOneTap({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/identity/google-one-tap",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+};
+
+// src/generated/services/JobService.ts
+var JobService = class {
+  /**
+   * Creates a new job definition.
+   * A preview pipeline is automatically created and returned in the response.
+   * @returns CreateJobDefinitionEndpoint_Output OK
+   * @throws ApiError
+   */
+  static postJobDefinition({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/job/definition",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Creates a new job from a job definition and audience.
+   * If the audience is not already recruiting, recruiting is started automatically.
+   * The RecruitingStarted field indicates whether this happened.
+   * @returns CreateJobEndpoint_Output OK
+   * @throws ApiError
+   */
+  static postJob({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/job",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Creates a new revision for an existing job definition.
+   * Unspecified fields are inherited from the previous revision. Workflow and Referee must be
+   * provided together if either is specified.
+   * @returns CreateJobRevisionEndpoint_Output OK
+   * @throws ApiError
+   */
+  static postJobDefinitionRevision({
+    definitionId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/job/definition/{definitionId}/revision",
+      path: {
+        "definitionId": definitionId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Gets the latest revision for a job definition.
+   * @returns GetJobRevisionEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getJobDefinitionRevision({
+    definitionId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/job/definition/{definitionId}/revision",
+      path: {
+        "definitionId": definitionId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Deletes a job definition and all its revisions.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteJobDefinition({
+    definitionId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/job/definition/{definitionId}",
+      path: {
+        "definitionId": definitionId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Gets a job definition by its id.
+   * @returns GetJobDefinitionByIdEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getJobDefinition({
+    definitionId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/job/definition/{definitionId}",
+      path: {
+        "definitionId": definitionId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Updates a job definition.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchJobDefinition({
+    definitionId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/job/definition/{definitionId}",
+      path: {
+        "definitionId": definitionId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Deletes a job.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteJob({
+    jobId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/job/{jobId}",
+      path: {
+        "jobId": jobId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Gets a job by its id.
+   * @returns GetJobByIdEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getJob({
+    jobId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/job/{jobId}",
+      path: {
+        "jobId": jobId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Updates a job.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchJob({
+    jobId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/job/{jobId}",
+      path: {
+        "jobId": jobId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Downloads the results of a job as a file attachment.
+   * @returns binary OK
+   * @throws ApiError
+   */
+  static getJobDownloadResults({
+    jobId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/job/{jobId}/download-results",
+      path: {
+        "jobId": jobId
+      },
+      errors: {
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Gets the results of a job as a JSON string.
+   * For file download, use the download-results endpoint instead.
+   * @returns string OK
+   * @throws ApiError
+   */
+  static getJobResults({
+    jobId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/job/{jobId}/results",
+      path: {
+        "jobId": jobId
+      },
+      errors: {
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Gets a specific revision for a job definition.
+   * @returns GetJobRevisionEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getJobDefinitionRevision1({
+    definitionId,
+    revisionNumber
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/job/definition/{definitionId}/revision/{revisionNumber}",
+      path: {
+        "definitionId": definitionId,
+        "revisionNumber": revisionNumber
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Queries job definitions based on filter, page, and sort criteria.
+   * @returns PagedResultOfQueryJobDefinitionsResult OK
+   * @throws ApiError
+   */
+  static getJobDefinitions({
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/job/definitions",
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Queries job revisions for a specific definition based on filter, page, and sort criteria.
+   * @returns PagedResultOfQueryJobRevisionsResult OK
+   * @throws ApiError
+   */
+  static getJobDefinitionRevisions({
+    definitionId,
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/job/definition/{definitionId}/revisions",
+      path: {
+        "definitionId": definitionId
+      },
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Queries jobs based on filter, page, and sort criteria.
+   * @returns PagedResultOfQueryJobsResult OK
+   * @throws ApiError
+   */
+  static getJobs({
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/jobs",
+      query: {
+        "request": request2
+      }
+    });
+  }
+};
+
+// src/generated/services/LeaderboardService.ts
+var LeaderboardService = class {
+  /**
+   * Returns the combined pairwise vote matrix for multiple leaderboards.
+   * @returns GetCombinedLeaderboardMatrixEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getLeaderboardCombinedMatrix({
+    leaderboardIds,
+    useWeightedScoring = false
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/leaderboard/combined-matrix",
+      query: {
+        "leaderboardIds": leaderboardIds,
+        "useWeightedScoring": useWeightedScoring
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Returns the combined standings for multiple leaderboards.
+   * @returns GetCombinedLeaderboardStandingsEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getLeaderboardCombinedStandings({
+    leaderboardIds,
+    useWeightedScoring = false,
+    includeConfidenceIntervals = false
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/leaderboard/combined-standings",
+      query: {
+        "leaderboardIds": leaderboardIds,
+        "useWeightedScoring": useWeightedScoring,
+        "includeConfidenceIntervals": includeConfidenceIntervals
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Returns the pairwise vote matrix for a leaderboard.
+   * The matrix is returned in pandas split format.
+   * @returns VoteMatrixResult OK
+   * @throws ApiError
+   */
+  static getLeaderboardMatrix({
+    leaderboardId,
+    tags,
+    useWeightedScoring = false
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/leaderboard/{leaderboardId}/matrix",
+      path: {
+        "leaderboardId": leaderboardId
+      },
+      query: {
+        "tags": tags,
+        "useWeightedScoring": useWeightedScoring
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Queries all leaderboards for a specific benchmark.
+   * @returns PagedResultOfLeaderboardsQueryResult OK
+   * @throws ApiError
+   */
+  static getLeaderboards({
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/leaderboards",
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Gets a leaderboard by its ID.
+   * @returns GetLeaderboardByIdResult OK
+   * @throws ApiError
+   */
+  static getLeaderboard({
+    leaderboardId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/leaderboard/{leaderboardId}",
+      path: {
+        "leaderboardId": leaderboardId
+      }
+    });
+  }
+  /**
+   * Updates the response config of a leaderboard.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchLeaderboard({
+    leaderboardId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/leaderboard/{leaderboardId}",
+      path: {
+        "leaderboardId": leaderboardId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Deletes a leaderboard by its ID.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteLeaderboard({
+    leaderboardId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/leaderboard/{leaderboardId}",
+      path: {
+        "leaderboardId": leaderboardId
+      }
+    });
+  }
+  /**
+   * Creates a new leaderboard with the specified name and criteria.
+   * @returns CreateLeaderboardResult OK
+   * @throws ApiError
+   */
+  static postLeaderboard({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/leaderboard",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * queries all the participants connected to leaderboard by its ID.
+   * @returns StandingsByLeaderboardResult OK
+   * @throws ApiError
+   */
+  static getLeaderboardStandings({
+    leaderboardId,
+    tags,
+    useWeightedScoring = false,
+    includeConfidenceIntervals = false
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/leaderboard/{leaderboardId}/standings",
+      path: {
+        "leaderboardId": leaderboardId
+      },
+      query: {
+        "tags": tags,
+        "useWeightedScoring": useWeightedScoring,
+        "includeConfidenceIntervals": includeConfidenceIntervals
+      }
+    });
+  }
+  /**
+   * Gets the runs related to a leaderboard
+   * @returns PagedResultOfRunsByLeaderboardResult OK
+   * @throws ApiError
+   */
+  static getLeaderboardRuns({
+    leaderboardId,
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/leaderboard/{leaderboardId}/runs",
+      path: {
+        "leaderboardId": leaderboardId
+      },
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Gets a standing by leaderboardId and participantId.
+   * @returns GetStandingByIdResult OK
+   * @throws ApiError
+   */
+  static getBenchmarkStanding({
+    leaderboardId,
+    participantId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark/standing/{leaderboardId}/{participantId}",
+      path: {
+        "leaderboardId": leaderboardId,
+        "participantId": participantId
+      }
+    });
+  }
+  /**
+   * Boosts a subset of participants within a leaderboard.
+   * @returns SubmitParticipantResult OK
+   * @throws ApiError
+   */
+  static postLeaderboardBoost({
+    leaderboardId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/leaderboard/{leaderboardId}/boost",
+      path: {
+        "leaderboardId": leaderboardId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+};
+
+// src/generated/services/NewsletterService.ts
+var NewsletterService = class {
+  /**
+   * Signs a user up to the newsletter.
+   * @returns void
+   * @throws ApiError
+   */
+  static postNewsletterSubscribe({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/newsletter/subscribe",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Unsubscribes a user from the newsletter.
+   * @returns void
+   * @throws ApiError
+   */
+  static postNewsletterUnsubscribe({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/newsletter/unsubscribe",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+};
+
+// src/generated/services/OrderService.ts
+var OrderService = class {
+  /**
+   * Approves a submitted order so the pipeline can start processing it.
+   * @returns void
+   * @throws ApiError
+   */
+  static postOrderApprove({
+    orderId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/order/{orderId}/approve",
+      path: {
+        "orderId": orderId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Clones an existing public order.
+   * The order to clone must be marked as public.
+   * @returns CloneOrderEndpoint_Output OK
+   * @throws ApiError
+   */
+  static postOrderClone({
+    orderId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/order/{orderId}/clone",
+      path: {
+        "orderId": orderId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Creates a new order with a custom pipeline configuration.
+   * @returns CreateComplexOrderEndpoint_Output OK
+   * @throws ApiError
+   */
+  static postOrderComplex({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/order/complex",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Creates a new order with the given configuration.
+   * Once created, use the returned dataset ID to fill the dataset with datapoints,
+   * then submit the order for processing.
+   * @returns CreateOrderEndpoint_Output OK
+   * @throws ApiError
+   */
+  static postOrder({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/order",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Creates a notification for an unsupported order type.
+   * @returns void
+   * @throws ApiError
+   */
+  static postOrderUnsupported({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/order/unsupported",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Deletes an order and its associated resources.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteOrder({
+    orderId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/order/{orderId}",
+      path: {
+        "orderId": orderId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Retrieves the details of a specific order.
+   * @returns GetOrderByIdEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getOrder({
+    orderId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/order/{orderId}",
+      path: {
+        "orderId": orderId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Updates the name or preceding order of an order.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchOrder({
+    orderId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/order/{orderId}",
+      path: {
+        "orderId": orderId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Aggregates the results of an order and returns them as a file attachment.
+   * @returns binary OK
+   * @throws ApiError
+   */
+  static getOrderDownloadResults({
+    orderId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/order/{orderId}/download-results",
+      path: {
+        "orderId": orderId
+      },
+      errors: {
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Aggregates the results of an order and returns them as a JSON string.
+   * For file download, use the download-results endpoint instead.
+   * @returns string OK
+   * @throws ApiError
+   */
+  static getOrderResults({
+    orderId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/order/{orderId}/results",
+      path: {
+        "orderId": orderId
+      },
+      errors: {
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Retrieves all publicly available orders.
+   * @returns GetPublicOrdersEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getOrdersPublic() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/orders/public",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Marks or unmarks an order as a demo.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchOrderDemo({
+    orderId,
+    isDemo = true
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/order/{orderId}/demo",
+      path: {
+        "orderId": orderId
+      },
+      query: {
+        "isDemo": isDemo
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Pauses an order, stopping all campaigns from processing.
+   * @returns void
+   * @throws ApiError
+   */
+  static postOrderPause({
+    orderId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/order/{orderId}/pause",
+      path: {
+        "orderId": orderId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Starts preview mode for an order so labelers' experience can be inspected.
+   * @returns void
+   * @throws ApiError
+   */
+  static postOrderPreview({
+    orderId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/order/{orderId}/preview",
+      path: {
+        "orderId": orderId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Retrieves orders aggregated by customer with total amounts and most recent order information.
+   * @returns QueryAggregatedOrdersEndpoint_PagedResultOfOutput OK
+   * @throws ApiError
+   */
+  static getOrdersAggregatedOverview({
+    page,
+    pageSize,
+    sort,
+    customerMail,
+    lastOrderDate,
+    lastOrderName
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/orders/aggregated-overview",
+      query: {
+        "page": page,
+        "page_size": pageSize,
+        "sort": sort,
+        "customer_mail": customerMail,
+        "last_order_date": lastOrderDate,
+        "last_order_name": lastOrderName
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * @returns QueryOrdersEndpoint_PagedResultOfOutput OK
+   * @throws ApiError
+   */
+  static getOrders({
+    page,
+    pageSize,
+    sort,
+    orderName,
+    state,
+    orderDate,
+    customerMail,
+    isPublic
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/orders",
+      query: {
+        "page": page,
+        "page_size": pageSize,
+        "sort": sort,
+        "order_name": orderName,
+        "state": state,
+        "order_date": orderDate,
+        "customer_mail": customerMail,
+        "is_public": isPublic
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Resumes a paused order, restarting all campaigns.
+   * @returns void
+   * @throws ApiError
+   */
+  static postOrderResume({
+    orderId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/order/{orderId}/resume",
+      path: {
+        "orderId": orderId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Retries processing of a failed order.
+   * @returns void
+   * @throws ApiError
+   */
+  static postOrderRetry({
+    orderId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/order/{orderId}/retry",
+      path: {
+        "orderId": orderId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Marks or unmarks an order as public.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchOrderShare({
+    orderId,
+    isPublic = true
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/order/{orderId}/share",
+      path: {
+        "orderId": orderId
+      },
+      query: {
+        "isPublic": isPublic
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Submits an order for processing.
+   * Once submitted, the order will be locked and no further changes can be made.
+   * @returns void
+   * @throws ApiError
+   */
+  static postOrderSubmit({
+    orderId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/order/{orderId}/submit",
+      path: {
+        "orderId": orderId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Unlocks a cloned order so it can be modified.
+   * Unlocking clones the entire dataset and its datapoints.
+   * @returns UnlockOrderEndpoint_Output OK
+   * @throws ApiError
+   */
+  static postOrderUnlock({
+    orderId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/order/{orderId}/unlock",
+      path: {
+        "orderId": orderId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/OrganizationService.ts
+var OrganizationService = class {
+  /**
+   * Returns a paged list of organizations.
+   * @returns QueryOrganizationsEndpoint_PagedResultOfOutput OK
+   * @throws ApiError
+   */
+  static getOrganizations({
+    page,
+    pageSize,
+    sort,
+    name,
+    domain,
+    owner
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations",
+      query: {
+        "page": page,
+        "page_size": pageSize,
+        "sort": sort,
+        "name": name,
+        "domain": domain,
+        "owner": owner
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/ParticipantService.ts
+var ParticipantService = class {
+  /**
+   * Adds a sample to a participant.
+   * @returns any OK
+   * @throws ApiError
+   */
+  static postParticipantSample({
+    participantId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/participant/{participantId}/sample",
+      path: {
+        "participantId": participantId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Deletes a participant on a benchmark.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteParticipant({
+    participantId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/participant/{participantId}",
+      path: {
+        "participantId": participantId
+      }
+    });
+  }
+  /**
+   * Gets a participant by it's Id.
+   * @returns GetParticipantByIdResult OK
+   * @throws ApiError
+   */
+  static getParticipant({
+    participantId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/participant/{participantId}",
+      path: {
+        "participantId": participantId
+      }
+    });
+  }
+  /**
+   * Updates a participant using patch semantics.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchParticipant({
+    participantId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/participant/{participantId}",
+      path: {
+        "participantId": participantId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Submits a participant to a benchmark.
+   * @returns SubmitParticipantResult OK
+   * @throws ApiError
+   */
+  static postParticipantsSubmit({
+    participantId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/participants/{participantId}/submit",
+      path: {
+        "participantId": participantId
+      }
+    });
+  }
+  /**
+   * Deletes a sample.
+   * @returns GetParticipantByIdResult OK
+   * @throws ApiError
+   */
+  static deleteParticipantSample({
+    sampleId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/participant-sample/{sampleId}",
+      path: {
+        "sampleId": sampleId
+      }
+    });
+  }
+  /**
+   * Queries all samples of a participant.
+   * @returns PagedResultOfISampleByParticipant OK
+   * @throws ApiError
+   */
+  static getParticipantSamples({
+    participantId,
+    request: request2,
+    fillMissing = false
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/participant/{participantId}/samples",
+      path: {
+        "participantId": participantId
+      },
+      query: {
+        "request": request2,
+        "fillMissing": fillMissing
+      }
+    });
+  }
+  /**
+   * This endpoint disables a participant in a benchmark. this means that the participant will no longer actively be matched up against other participants and not collect further results. It will still be visible in the leaderboard.
+   * @returns any OK
+   * @throws ApiError
+   */
+  static postParticipantDisable({
+    participantId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/participant/{participantId}/disable",
+      path: {
+        "participantId": participantId
+      }
+    });
+  }
+};
+
+// src/generated/services/PipelineService.ts
+var PipelineService = class {
+  /**
+   * Gets a pipeline by its id.
+   * @returns GetPipelineByIdResult OK
+   * @throws ApiError
+   */
+  static getPipeline({
+    pipelineId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/pipeline/{pipelineId}",
+      path: {
+        "pipelineId": pipelineId
+      }
+    });
+  }
+  /**
+   * Initiates a preliminary download of the pipeline.
+   * @returns StartPreliminaryDownloadResult OK
+   * @throws ApiError
+   */
+  static postPipelinePreliminaryDownload({
+    pipelineId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/pipeline/{pipelineId}/preliminary-download",
+      path: {
+        "pipelineId": pipelineId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Gets the preliminary download.
+   * If it's still processing the request will return 202 Accepted.
+   * @returns FileStreamResult OK
+   * @returns any Accepted
+   * @throws ApiError
+   */
+  static getPipelinePreliminaryDownload({
+    preliminaryDownloadId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/pipeline/preliminary-download/{preliminaryDownloadId}",
+      path: {
+        "preliminaryDownloadId": preliminaryDownloadId
+      }
+    });
+  }
+};
+
+// src/generated/services/PromptService.ts
+var PromptService = class {
+  /**
+   * Updates the tags associated with a prompt.
+   * @returns void
+   * @throws ApiError
+   */
+  static putBenchmarkPromptTags({
+    promptId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/benchmark-prompt/{promptId}/tags",
+      path: {
+        "promptId": promptId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+};
+
+// src/generated/services/RankingFlowService.ts
+var RankingFlowService = class {
+  /**
+   * Creates a new ranking flow.
+   * @returns CreateFlowEndpoint_Output OK
+   * @throws ApiError
+   */
+  static postFlowRanking({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/flow/ranking",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Updates the configuration of a ranking flow.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchFlowRankingConfig({
+    flowId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/flow/ranking/{flowId}/config",
+      path: {
+        "flowId": flowId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/RankingFlowItemService.ts
+var RankingFlowItemService = class {
+  /**
+   * Creates a new flow item for the specified flow.
+   * @returns CreateFlowItemEndpoint_Output OK
+   * @throws ApiError
+   */
+  static postFlowRankingItem({
+    flowId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/flow/ranking/{flowId}/item",
+      path: {
+        "flowId": flowId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Queries flow items for a flow.
+   * @returns QueryFlowItemsEndpoint_PagedResultOfOutput OK
+   * @throws ApiError
+   */
+  static getFlowRankingItem({
+    flowId,
+    page,
+    pageSize,
+    sort,
+    state,
+    createdAt
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/flow/ranking/{flowId}/item",
+      path: {
+        "flowId": flowId
+      },
+      query: {
+        "page": page,
+        "page_size": pageSize,
+        "sort": sort,
+        "state": state,
+        "created_at": createdAt
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Retrieves a flow item by its ID.
+   * @returns GetFlowItemByIdEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getFlowRankingItem1({
+    flowItemId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/flow/ranking/item/{flowItemId}",
+      path: {
+        "flowItemId": flowItemId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Returns ranking results with Elo scores for a completed flow item.
+   * Returns 409 Conflict if the flow item is not yet completed or has no associated workflow.
+   * @returns GetRankingFlowItemResultsEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getFlowRankingItemResults({
+    flowItemId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/flow/ranking/item/{flowItemId}/results",
+      path: {
+        "flowItemId": flowItemId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`,
+        409: `Conflict`
+      }
+    });
+  }
+  /**
+   * Retrieves the pairwise vote matrix for a completed flow item.
+   * Returns 409 Conflict if the flow item is not completed or has no associated workflow.
+   * @returns GetRankingFlowItemVoteMatrixEndpoint_Output OK
+   * @throws ApiError
+   */
+  static getFlowRankingItemVoteMatrix({
+    flowItemId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/flow/ranking/item/{flowItemId}/vote-matrix",
+      path: {
+        "flowItemId": flowItemId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`,
+        409: `Conflict`
+      }
+    });
+  }
+};
+
+// src/generated/services/RankingWorkflowService.ts
+var RankingWorkflowService = class {
+  /**
+   * Get the result overview for a ranking workflow.
+   * @returns GetRankingWorkflowResultsResult OK
+   * @throws ApiError
+   */
+  static getWorkflowCompareResults({
+    workflowId,
+    model
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workflow/compare/{workflowId}/results",
+      path: {
+        "workflowId": workflowId
+      },
+      query: {
+        "model": model
+      }
+    });
+  }
+};
+
+// src/generated/services/RapidService.ts
+var RapidService = class {
+  /**
+   * Rejects a completed rapid, marking its results as invalid.
+   * The rapid must be in the Done state. Rejection propagates staleness to dependent entities.
+   * @returns void
+   * @throws ApiError
+   */
+  static postRapidReject({
+    rapidId
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/rapid/{rapidId}/reject",
+      path: {
+        "rapidId": rapidId
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/RapidataIdentityApiService.ts
+var RapidataIdentityApiService = class {
+  /**
+   * @returns any OK
+   * @throws ApiError
+   */
+  static get() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/"
+    });
+  }
+};
+
+// src/generated/services/RapidsService.ts
+var RapidsService = class {
+  /**
+   * Updates a rapid's validation properties within an audience.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchAudienceRapid({
+    audienceId,
+    rapidId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/audience/{audienceId}/rapid/{rapidId}",
+      path: {
+        "audienceId": audienceId,
+        "rapidId": rapidId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/SampleService.ts
+var SampleService = class {
+  /**
+   * Gets a sample by its Id.
+   * @returns GetSampleByIdResult OK
+   * @throws ApiError
+   */
+  static getBenchmarkSample({
+    sampleId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/benchmark-sample/{sampleId}",
+      path: {
+        "sampleId": sampleId
+      }
+    });
+  }
+};
+
+// src/generated/services/SimpleWorkflowService.ts
+var SimpleWorkflowService = class {
+  /**
+   * Get the result overview for a simple workflow.
+   * @returns PagedResultOfGetWorkflowResultsResult OK
+   * @throws ApiError
+   */
+  static getWorkflowSimpleResults({
+    workflowId,
+    model
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workflow/simple/{workflowId}/results",
+      path: {
+        "workflowId": workflowId
+      },
+      query: {
+        "model": model
+      }
+    });
+  }
+};
+
+// src/generated/services/SurveyService.ts
+var SurveyService = class {
+  /**
+   * Sends a survey.
+   * @returns any OK
+   * @throws ApiError
+   */
+  static postIdentitySurvey({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/identity/survey",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+};
+
+// src/generated/services/UserRapidService.ts
+var UserRapidService = class {
+  /**
+   * Validates that the rapids associated with the current user are active.
+   * @returns AreRapidsActiveResult OK
+   * @throws ApiError
+   */
+  static getRapidRapidBagIsValid() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/rapid/rapid-bag/is-valid"
+    });
+  }
+  /**
+   * Submits a response for a Rapid.
+   * @returns AddUserResponseResult OK
+   * @throws ApiError
+   */
+  static postRapidResponse({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/rapid/response",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Skips a Rapid for the user.
+   * @returns AddUserResponseResult OK
+   * @throws ApiError
+   */
+  static postRapidSkip({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/rapid/skip",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Used to report an issue with a rapid.
+   * @returns void
+   * @throws ApiError
+   */
+  static postRapidReport({
+    rapidId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/rapid/{rapidId}/report",
+      path: {
+        "rapidId": rapidId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Inspects a report's dump. Can be used to restore zustand state or anything alike.
+   * @returns InspectReportResult OK
+   * @throws ApiError
+   */
+  static getRapidReport({
+    reportId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/rapid/report/{reportId}",
+      path: {
+        "reportId": reportId
+      }
+    });
+  }
+};
+
+// src/generated/services/ValidationFeedbackService.ts
+var ValidationFeedbackService = class {
+  /**
+   * Submits feedback for a validation rapid outcome.
+   * @returns void
+   * @throws ApiError
+   */
+  static postRapidValidationFeedback({
+    rapidId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/rapid/{rapidId}/validation-feedback",
+      path: {
+        "rapidId": rapidId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+  /**
+   * Queries validation feedbacks for a rapid.
+   * @returns QueryValidationFeedbacksEndpoint_PagedResultOfOutput OK
+   * @throws ApiError
+   */
+  static getRapidValidationFeedback({
+    rapidId,
+    page,
+    pageSize,
+    sort,
+    userId,
+    feedback,
+    createdAt
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/rapid/{rapidId}/validation-feedback",
+      path: {
+        "rapidId": rapidId
+      },
+      query: {
+        "page": page,
+        "page_size": pageSize,
+        "sort": sort,
+        "user_id": userId,
+        "feedback": feedback,
+        "created_at": createdAt
+      },
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthenticated`,
+        403: `Forbidden`
+      }
+    });
+  }
+};
+
+// src/generated/services/ValidationSetService.ts
+var ValidationSetService = class {
+  /**
+   * Queries available validation sets based on the provided filter, paging and sorting criteria.
+   * @returns PagedResultOfValidationSetModel OK
+   * @throws ApiError
+   */
+  static getValidationSets({
+    model
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/validation-sets",
+      query: {
+        "model": model
+      }
+    });
+  }
+  /**
+   * Gets a validation set that is available to the user and best matches the provided parameters.
+   * This is not a hard filter, instead it is used to find validation sets that have similar characteristics to the provided instruction.
+   * @returns GetRecommendedValidationSetResult OK
+   * @throws ApiError
+   */
+  static getValidationSetRecommended({
+    assetType,
+    modality,
+    promptType,
+    instruction
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/validation-set/recommended",
+      query: {
+        "assetType": assetType,
+        "modality": modality,
+        "promptType": promptType,
+        "instruction": instruction
+      },
+      errors: {
+        404: `Not Found`
+      }
+    });
+  }
+  /**
+   * Gets a validation set by the id.
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteValidationSet({
+    validationSetId
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/validation-set/{validationSetId}",
+      path: {
+        "validationSetId": validationSetId
+      }
+    });
+  }
+  /**
+   * Gets a validation set by the id.
+   * @returns GetValidationSetByIdResult OK
+   * @throws ApiError
+   */
+  static getValidationSet({
+    validationSetId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/validation-set/{validationSetId}",
+      path: {
+        "validationSetId": validationSetId
+      }
+    });
+  }
+  /**
+   * Updates different characteristics of a validation set.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchValidationSet({
+    validationSetId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/validation-set/{validationSetId}",
+      path: {
+        "validationSetId": validationSetId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Gets the available validation sets for the current user.
+   * @returns GetAvailableValidationSetsResult OK
+   * @throws ApiError
+   */
+  static getValidationSetsAvailable() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/validation-sets/available"
+    });
+  }
+  /**
+   * Creates a new empty validation set.
+   * @returns CreateEmptyValidationSetResult OK
+   * @throws ApiError
+   */
+  static postValidationSet({
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/validation-set",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Queries the validation rapids for a specific validation set.
+   * @returns PagedResultOfGetValidationRapidsResult OK
+   * @throws ApiError
+   */
+  static getValidationSetRapids({
+    validationSetId,
+    model
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/validation-set/{validationSetId}/rapids",
+      path: {
+        "validationSetId": validationSetId
+      },
+      query: {
+        "model": model
+      }
+    });
+  }
+  /**
+   * Adds a new validation rapid to the validation set using JSON body.
+   * @returns void
+   * @throws ApiError
+   */
+  static postValidationSetRapid({
+    validationSetId,
+    requestBody
+  }) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/validation-set/{validationSetId}/rapid",
+      path: {
+        "validationSetId": validationSetId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Updates the visibility of a validation set.
+   * Public validation sets are used to automatically add a validation set to an order if no validation set is specified.
+   * @returns void
+   * @throws ApiError
+   */
+  static patchValidationSetVisibility({
+    validationSetId,
+    isPublic
+  }) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/validation-set/{validationSetId}/visibility",
+      path: {
+        "validationSetId": validationSetId
+      },
+      query: {
+        "isPublic": isPublic
+      }
+    });
+  }
+  /**
+   * Exports all rapids of a validation-set to a file.
+   * @returns FileStreamResult OK
+   * @throws ApiError
+   */
+  static getValidationSetExport({
+    validationSetId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/validation-set/{validationSetId}/export",
+      path: {
+        "validationSetId": validationSetId
+      }
+    });
+  }
+};
+
+// src/generated/services/WorkflowService.ts
+var WorkflowService = class {
+  /**
+   * Queries workflows based on the provided filter, page, and sort criteria.
+   * @returns PagedResultOfIWorkflowModel OK
+   * @throws ApiError
+   */
+  static getWorkflows({
+    request: request2
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workflows",
+      query: {
+        "request": request2
+      }
+    });
+  }
+  /**
+   * Get a workflow by its ID.
+   * @returns GetWorkflowByIdResult OK
+   * @throws ApiError
+   */
+  static getWorkflow({
+    workflowId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workflow/{workflowId}",
+      path: {
+        "workflowId": workflowId
+      }
+    });
+  }
+  /**
+   * Get the progress of a workflow.
+   * @returns GetWorkflowProgressResult OK
+   * @throws ApiError
+   */
+  static getWorkflowProgress({
+    workflowId
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workflow/{workflowId}/progress",
+      path: {
+        "workflowId": workflowId
+      }
+    });
+  }
+  /**
+   * Calculates a summary of the results for a simple ranking workflow.
+   * The summary includes the number of times an asset at each index was the winner.
+   * @returns GetCompareAbSummaryResult OK
+   * @throws ApiError
+   */
+  static getWorkflowCompareAbSummary({
+    workflowId,
+    useUserScore = false
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workflow/{workflowId}/compare-ab-summary",
+      path: {
+        "workflowId": workflowId
+      },
+      query: {
+        "useUserScore": useUserScore
+      }
+    });
+  }
+  /**
+   * Gets the limit most recent or oldest responses for a workflow.
+   * The responses are not guaranteed to be of any specific rapid.
+   * Instead, this endpoint returns all responses to any rapid in the workflow.
+   * @returns GetResponsesResult OK
+   * @throws ApiError
+   */
+  static getWorkflowResponses({
+    workflowId,
+    limit = 100,
+    sort
+  }) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workflow/{workflowId}/responses",
+      path: {
+        "workflowId": workflowId
+      },
+      query: {
+        "limit": limit,
+        "sort": sort
+      }
+    });
+  }
+  /**
+   * Deletes a workflow.
+   * @returns any OK
+   * @throws ApiError
+   */
+  static deleteWorkflowDelete({
+    id
+  }) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/workflow/delete",
+      query: {
+        "id": id
+      }
+    });
+  }
+};
+
+exports.ApiError = ApiError;
+exports.AssetService = AssetService;
+exports.AudienceService = AudienceService;
+exports.BatchUploadService = BatchUploadService;
+exports.BenchmarkService = BenchmarkService;
+exports.CacheService = CacheService;
+exports.CampaignService = CampaignService;
+exports.CancelError = CancelError;
+exports.CancelablePromise = CancelablePromise;
+exports.ClientService = ClientService;
+exports.CustomerRapidService = CustomerRapidService;
+exports.CustomerService = CustomerService;
+exports.DatapointService = DatapointService;
+exports.DatasetGroupService = DatasetGroupService;
+exports.DatasetService = DatasetService;
+exports.EvaluationWorkflowService = EvaluationWorkflowService;
+exports.ExamplesService = ExamplesService;
+exports.FeedbackService = FeedbackService;
+exports.FlowItemService = FlowItemService;
+exports.FlowService = FlowService;
+exports.GroupedRankingWorkflowService = GroupedRankingWorkflowService;
+exports.IdentityService = IdentityService;
+exports.JobService = JobService;
+exports.LeaderboardService = LeaderboardService;
+exports.NewsletterService = NewsletterService;
+exports.OpenAPI = OpenAPI;
+exports.OrderService = OrderService;
+exports.OrganizationService = OrganizationService;
+exports.ParticipantService = ParticipantService;
+exports.PipelineService = PipelineService;
+exports.PromptService = PromptService;
+exports.RankingFlowItemService = RankingFlowItemService;
+exports.RankingFlowService = RankingFlowService;
+exports.RankingWorkflowService = RankingWorkflowService;
+exports.RapidService = RapidService;
+exports.RapidataIdentityApiService = RapidataIdentityApiService;
+exports.RapidsService = RapidsService;
+exports.SampleService = SampleService;
+exports.SimpleWorkflowService = SimpleWorkflowService;
+exports.SurveyService = SurveyService;
+exports.UserRapidService = UserRapidService;
+exports.ValidationFeedbackService = ValidationFeedbackService;
+exports.ValidationSetService = ValidationSetService;
+exports.WorkflowService = WorkflowService;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map